Tôi đang đọc thêm Joel trên phần mềm khi tôi bắt gặp Joel Spolsky nói điều gì đó về một loại lập trình viên cụ thể biết sự khác biệt giữa một intvà một Integertrong Java / C # (Ngôn ngữ lập trình hướng đối tượng).
Vì vậy, sự khác biệt là gì?
Câu trả lời:
Trong Java, loại 'int' là nguyên thủy, trong khi loại 'Integer' là một đối tượng.
Trong C #, loại 'int' giống System.Int32và là loại giá trị (nghĩa là giống với 'int' java hơn). Một số nguyên (giống như bất kỳ loại giá trị nào khác) có thể được đóng hộp ("bọc") vào một đối tượng.
Sự khác biệt giữa các đối tượng và nguyên thủy có phần vượt quá phạm vi của câu hỏi này, nhưng để tóm tắt:
Các đối tượng cung cấp các phương tiện cho đa hình, được truyền bằng tham chiếu (hoặc chính xác hơn là có các tham chiếu được truyền theo giá trị) và được phân bổ từ heap . Ngược lại, nguyên thủy là các loại bất biến được truyền theo giá trị và thường được phân bổ từ ngăn xếp .
Chà, trong Java một int là nguyên thủy trong khi Integer là Object. Có nghĩa là, nếu bạn đã tạo một số nguyên mới:
Integer i = new Integer(6);Bạn có thể gọi một số phương thức trên i:
String s = i.toString();//sets s the string representation of iTrong khi đó với một int:
int i = 6;Bạn không thể gọi bất kỳ phương thức nào trên đó, bởi vì nó đơn giản là nguyên thủy. Vì thế:
String s = i.toString();//will not work!!!sẽ tạo ra một lỗi, bởi vì int không phải là một đối tượng.
int là một trong số ít các nguyên thủy trong Java (cùng với char và một số thứ khác). Tôi không chắc chắn 100%, nhưng tôi nghĩ rằng đối tượng Integer ít nhiều chỉ có một thuộc tính int và cả đống phương thức để tương tác với thuộc tính đó (ví dụ như phương thức toString ()). Vì vậy, Integer là một cách thú vị để làm việc với một int (Giống như có lẽ String là một cách thú vị để làm việc với một nhóm các ký tự).
Tôi biết rằng Java không phải là C, nhưng vì tôi chưa bao giờ lập trình trong C nên đây là lần gần nhất tôi có thể đi đến câu trả lời. Hi vọng điêu nay co ich!
Tôi sẽ thêm vào các câu trả lời tuyệt vời được đưa ra ở trên, và nói về quyền anh và unboxing, và cách này áp dụng cho Java (mặc dù C # cũng có nó). Tôi sẽ chỉ sử dụng thuật ngữ Java vì tôi không thích điều đó.
Như các câu trả lời đã đề cập, intchỉ là một số (được gọi là loại không có hộp ), trong khi đó Integerlà một đối tượng (chứa số đó, do đó là loại được đóng hộp ). Xét về Java, mà phương tiện (ngoại trừ việc không thể gọi các phương thức trên int), bạn không thể lưu trữ inthoặc các loại phi vật thể khác trong bộ sưu tập ( List, Map, vv). Để lưu trữ chúng, trước tiên bạn phải đóng hộp chúng theo kiểu đóng hộp tương ứng.
Java 5 trở đi có một thứ gọi là tự động đấm bốc và tự động mở hộp cho phép đấm bốc / bỏ hộp được thực hiện ở hậu trường. So sánh và tương phản: Phiên bản Java 5:
Deque<Integer> queue;
void add(int n) {
queue.add(n);
}
int remove() {
return queue.remove();
}Java 1.4 trở về trước (không có chung chung):
Deque queue;
void add(int n) {
queue.add(Integer.valueOf(n));
}
int remove() {
return ((Integer) queue.remove()).intValue();
}Cần lưu ý rằng mặc dù có sự ngắn gọn trong phiên bản Java 5, cả hai phiên bản đều tạo mã byte giống hệt nhau. Do đó, mặc dù tự động đấm bốc và tự động mở hộp rất thuận tiện vì bạn viết ít mã hơn, các thao tác này thực hiện sau hậu trường, với cùng chi phí thời gian chạy, do đó bạn vẫn phải biết về sự tồn tại của chúng.
Hi vọng điêu nay co ich!
Tôi sẽ chỉ đăng ở đây vì một số bài đăng khác hơi không chính xác liên quan đến C #.
Đúng: int là một bí danh cho System.Int32.
Sai: float không phải là bí danh cho System.Float, nhưng choSystem.Single
Về cơ bản, int là một từ khóa dành riêng trong ngôn ngữ lập trình C # và là bí danh cho System.Int32loại giá trị.
Tuy nhiên, float và Float không giống nhau, vì loại hệ thống phù hợp cho '' float'' là System.Single. Có một số loại như thế này có các từ khóa dành riêng dường như không khớp với tên loại trực tiếp.
Trong C # không có sự khác biệt giữa '' int'' và '' System.Int32'', hoặc bất kỳ cặp hoặc từ khóa / loại hệ thống nào khác, ngoại trừ khi xác định enum. Với enums, bạn có thể chỉ định kích thước lưu trữ sẽ sử dụng và trong trường hợp này, bạn chỉ có thể sử dụng từ khóa dành riêng, chứ không phải tên loại thời gian chạy hệ thống.
Giá trị trong int sẽ được lưu trữ trên ngăn xếp, trong bộ nhớ hoặc dưới dạng đối tượng heap được tham chiếu tùy thuộc vào ngữ cảnh và cách bạn sử dụng nó.
Tuyên bố này trong một phương thức:
int i;định nghĩa một biến iloại System.Int32, sống trong một thanh ghi hoặc trên ngăn xếp, tùy thuộc vào tối ưu hóa. Khai báo tương tự trong một loại (struct hoặc class) xác định một trường thành viên. Khai báo tương tự trong danh sách đối số phương thức xác định một tham số, với cùng các tùy chọn lưu trữ như đối với một biến cục bộ. (lưu ý rằng đoạn này không hợp lệ nếu bạn bắt đầu kéo các phương thức lặp vào hỗn hợp, đây là những con thú khác nhau hoàn toàn)
Để có được một đối tượng heap, bạn có thể sử dụng quyền anh:
object o = i;điều này sẽ tạo ra một bản sao đóng hộp của nội dung itrên heap. Trong IL bạn có thể truy cập trực tiếp các phương thức trên đối tượng heap, nhưng trong C #, bạn cần chuyển nó trở lại int, nó sẽ tạo một bản sao khác. Do đó, đối tượng trên heap không thể dễ dàng thay đổi trong C # mà không tạo bản sao đóng hộp mới của giá trị int mới. (Ugh, đoạn này không đọc được tất cả một cách dễ dàng.)
Về Java 1.5 và autoboxing, có một "trò chơi" quan trọng được sử dụng khi so sánh các đối tượng Integer.
Trong Java, Integer đối tượng với các giá trị -128 đến 127 là không thay đổi (có nghĩa là, đối với một giá trị số nguyên đặc biệt, nói 23, tất cả các đối tượng Integer instantiated thông qua chương trình của bạn với giá trị 23 điểm đến chính xác cùng một đối tượng).
Ví dụ, điều này trả về đúng:
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2); // trueTrong khi điều này trả về false:
Integer i1 = new Integer(128);
Integer i2 = new Integer(128);
System.out.println(i1 == i2); // false== so sánh theo tham chiếu (không các biến trỏ đến cùng một đối tượng).
Kết quả này có thể có hoặc không khác nhau tùy thuộc vào JVM mà bạn đang sử dụng. Hộp tự động đặc tả cho Java 1.5 yêu cầu các số nguyên (-128 đến 127) luôn luôn đóng hộp cho cùng một đối tượng trình bao bọc.
Một giải pháp? =) Người ta phải luôn luôn sử dụng phương thức Integer.equals () khi so sánh các đối tượng Integer.
System.out.println(i1.equals(i2)); // trueThông tin thêm tại java.net Ví dụ tại bexhuff.com
127được lấy từsun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
Trong Java có hai loại cơ bản trong JVM . 1) Các kiểu nguyên thủy và 2) Các kiểu tham chiếu. int là kiểu nguyên thủy và Integer là kiểu lớp (là kiểu tham chiếu).
Các giá trị nguyên thủy không chia sẻ trạng thái với các giá trị nguyên thủy khác. Một biến có kiểu là kiểu nguyên thủy luôn giữ giá trị nguyên thủy của kiểu đó.
int aNumber = 4;
int anotherNum = aNumber;
aNumber += 6;
System.out.println(anotherNum); // Prints 4Một đối tượng là một thể hiện lớp được tạo động hoặc một mảng. Các giá trị tham chiếu (thường chỉ là tham chiếu) là các con trỏ tới các đối tượng này và một tham chiếu null đặc biệt, tham chiếu đến không có đối tượng. Có thể có nhiều tài liệu tham khảo cho cùng một đối tượng.
Integer aNumber = Integer.valueOf(4);
Integer anotherNumber = aNumber; // anotherNumber references the
// same object as aNumberNgoài ra trong Java mọi thứ đều được truyền bằng giá trị. Với các đối tượng, giá trị được truyền là tham chiếu đến đối tượng. Vì vậy, một sự khác biệt khác giữa int và Integer trong java là cách chúng được truyền trong các lệnh gọi phương thức. Ví dụ trong
public int add(int a, int b) {
return a + b;
}
final int two = 2;
int sum = add(1, two);Biến hai được truyền dưới dạng nguyên nguyên loại 2. Trong khi đó
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);Biến hai được truyền dưới dạng tham chiếu đến một đối tượng chứa giá trị nguyên 2.
@WolfmanDragon: Chuyển qua tham chiếu sẽ hoạt động như vậy:
public void increment(int x) {
x = x + 1;
}
int a = 1;
increment(a);
// a is now 2Khi gia tăng được gọi, nó chuyển một tham chiếu (con trỏ) đến biến a . Và hàm tăng trực tiếp sửa đổi biến a .
Và đối với các loại đối tượng, nó sẽ hoạt động như sau:
public void increment(Integer x) {
x = Integer.valueOf(x.intValue() + 1);
}
Integer a = Integer.valueOf(1);
increment(a);
// a is now 2Bạn có thấy sự khác biệt bây giờ không?
Trong C #, int chỉ là bí danh cho System.Int32, chuỗi cho System.String, gấp đôi cho System.Doublev.v ...
Cá nhân tôi thích int, chuỗi, double, v.v. vì họ không yêu cầu một using System;tuyên bố :) Một lý do ngớ ngẩn, tôi biết ...
Điều này đã được trả lời cho Java, đây là câu trả lời C #:
"Integer" không phải là tên loại hợp lệ trong C # và "int" chỉ là bí danh cho System.Int32. Ngoài ra, không giống như trong Java (hoặc C ++), không có bất kỳ loại nguyên thủy đặc biệt nào trong C #, mọi phiên bản của một loại trong C # (bao gồm cả int) là một đối tượng. Đây là một số mã trình diễn:
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 được sử dụng để khai báo biến nguyên thủy
e.g. int i=10;Số nguyên được sử dụng để tạo biến tham chiếu của lớp Integer
Integer a = new Integer();Trong các nền tảng như Java, ints là nguyên thủy trong khi Integerlà một đối tượng chứa trường số nguyên. Sự khác biệt quan trọng là người nguyên thủy luôn được truyền qua giá trị và theo định nghĩa là bất biến.
Bất kỳ hoạt động liên quan đến một biến nguyên thủy luôn trả về một giá trị mới. Mặt khác, các đối tượng được truyền xung quanh bằng cách tham chiếu. Người ta có thể lập luận rằng điểm đến đối tượng (AKA tham chiếu) cũng đang được truyền qua giá trị, nhưng nội dung thì không.
Một điều nữa mà tôi không thấy trong các câu trả lời trước: Trong Java, các lớp trình bao bọc nguyên thủy như Integer, Double, Float, Boolean ... và String được coi là bất biến, do đó khi bạn vượt qua một thể hiện của các lớp đó, nó được gọi phương thức không thể thay đổi dữ liệu của bạn theo bất kỳ cách nào, trong opositión với hầu hết các lớp khác, dữ liệu nội bộ có thể bị thay đổi bởi các phương thức công khai. Vì vậy, các lớp này chỉ có các phương thức 'getter', không có 'setters', bên cạnh hàm tạo.
Trong một chương trình java, chuỗi ký tự được lưu trữ trong một phần riêng biệt của bộ nhớ heap, chỉ một thể hiện cho nghĩa đen, để lưu lại bộ nhớ sử dụng lại các phiên bản đó
Bạn đã bao giờ lập trình trước đó rồi (int) là một trong những kiểu nguyên thủy bạn có thể đặt cho các biến của mình (giống như char, float, ...).
nhưng Integer là một lớp bao bọc mà bạn có thể sử dụng nó để thực hiện một số hàm trên một biến int (ví dụ: chuyển đổi nó thành chuỗi hoặc vise ngược lại, ...), nhưng lưu ý rằng các phương thức trong các lớp bao bọc là tĩnh để bạn có thể sử dụng chúng bất cứ lúc nào mà không tạo một thể hiện của lớp Integer. như một bản tóm tắt:
int x;
Integer y; x và y là cả hai biến kiểu int nhưng y được bao bọc bởi một lớp Integer và có một số phương thức mà bạn sử dụng, nhưng trong trường hợp bạn cần gọi một số hàm của lớp trình bao bọc Integer, bạn có thể thực hiện một cách đơn giản.
Integer.toString(x);nhưng lưu ý rằng cả x và y đều là corect nhưng nếu bạn muốn sử dụng chúng như một kiểu nguyên thủy, hãy sử dụng mẫu đơn giản (được sử dụng để xác định x).
Java:
int, double, long, byte, float, double, short, boolean, char- nguyên thủy. Được sử dụng để giữ các loại dữ liệu cơ bản được hỗ trợ bởi ngôn ngữ. các kiểu nguyên thủy không phải là một phần của hệ thống phân cấp đối tượng và chúng không kế thừa Object. Không thể vượt qua bằng cách tham chiếu đến một phương thức.
Double, Float, Long, Integer, Short, Byte, Character, Và Boolean, là loại đóng gói, đóng gói trong java.lang. Tất cả các hàm bao kiểu số xác định các hàm tạo cho phép một đối tượng được xây dựng từ một giá trị đã cho hoặc biểu diễn chuỗi của giá trị đó. Sử dụng các đối tượng có thể thêm một chi phí để tính toán đơn giản nhất.
Bắt đầu với JDK 5, Java đã bao gồm hai tính năng rất hữu ích: autoboxing và autounboxing. Autoboxing / unboxing đơn giản hóa rất nhiều và hợp lý hóa mã phải chuyển đổi các kiểu nguyên thủy thành các đối tượng và ngược lại.
Ví dụ về các nhà xây dựng:
Integer(int num)
Integer(String str) throws NumberFormatException
Double(double num)
Double(String str) throws NumberFormatExceptionVí dụ về quyền anh / 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
}
}Ví dụ về 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
}
}Cuốn sách của PS Herbert Schildt được lấy làm tài liệu tham khảo.
Một biến int chứa giá trị nguyên được ký 32 bit. Một số nguyên (có vốn I) giữ một tham chiếu đến một đối tượng của kiểu số nguyên (lớp) hoặc thành null.
Java tự động chuyển giữa hai cái; từ Integer đến int bất cứ khi nào đối tượng Integer xuất hiện dưới dạng đối số cho toán tử int hoặc được gán cho biến int hoặc giá trị int được gán cho biến Integer. Đúc này được gọi là đấm bốc / unboxing.
Nếu một biến số nguyên tham chiếu null được bỏ hộp, rõ ràng hoặc ngầm định, một NullPulumException sẽ bị ném.
Một int và Integer trong Java và C # là hai thuật ngữ khác nhau được sử dụng để thể hiện những thứ khác nhau. Đây là một trong những kiểu dữ liệu nguyên thủy có thể được gán cho một biến có thể lưu trữ chính xác. Một giá trị của loại khai báo tại một thời điểm.
Ví dụ:
int number = 7;Trường hợp intkiểu dữ liệu được gán cho số biến chứa giá trị bảy. Vì vậy, an intchỉ là một nguyên thủy không phải là một đối tượng.
Trong khi an Integerlà một lớp bao bọc cho kiểu dữ liệu nguyên thủy có các phương thức tĩnh. Điều đó có thể được sử dụng làm đối số cho phương thức yêu cầu một đối tượng, trong đó int có thể được sử dụng làm đối số cho phương thức yêu cầu giá trị nguyên, có thể được sử dụng cho biểu thức số học.
Ví dụ:
Integer number = new Integer(5);Trong cả hai ngôn ngữ (Java và C #) intlà số nguyên có chữ ký 4 byte.
Không giống như Java, C # Cung cấp cả các giá trị nguyên được ký và không dấu. Vì Java và C # là hướng đối tượng, một số thao tác trong các ngôn ngữ này không ánh xạ trực tiếp vào các hướng dẫn được cung cấp bởi thời gian chạy và do đó cần phải được xác định là một phần của một loại đối tượng.
C # cung cấp System.Int32loại giá trị sử dụng một phần bộ nhớ thuộc loại tham chiếu trên heap.
java cung cấp java.lang.Integermột kiểu tham chiếu hoạt động trên int. Các phương pháp trong Integerlon không được biên dịch trực tiếp để chạy thời gian instructions.So chúng tôi hộp một giá trị int để chuyển đổi nó thành một thể hiện của Integer và sử dụng các phương pháp mà hy vọng thể hiện của một số loại (như toString(), parseInt(), valueOf()vv).
Trong biến C # int đề cập đến System.Int32.Anygiá trị 4 byte trong bộ nhớ có thể được hiểu là int nguyên thủy, có thể được thao tác bằng thể hiện của System.Int32.So int là bí danh để System.Int32.Whensử dụng các phương thức liên quan đến số nguyên như int.Parse(), int.ToString()v.v. System.Int32cấu trúc FCL gọi các phương thức tương ứng như Int32.Parse(), Int32.ToString().
Trong Java, intkiểu là một kiểu dữ liệu nguyên thủy, trong đó Integerkiểu là một đối tượng.
Trong C #, intkiểu này cũng là kiểu dữ liệu giống như System.Int32. Một integer(giống như bất kỳ loại giá trị nào khác) có thể được đóng hộp ("bọc") vào một đối tượng.
Trong Java int là kiểu dữ liệu nguyên thủy trong khi Integer là lớp Trình trợ giúp, nó được sử dụng để chuyển đổi cho một loại dữ liệu này sang loại dữ liệu khác.
Ví dụ:
double doubleValue = 156.5d;
Double doubleObject = new Double(doubleValue);
Byte myByteValue = doubleObject.byteValue ();
String myStringValue = doubleObject.toString();Các kiểu dữ liệu nguyên thủy được lưu trữ bộ nhớ khả dụng nhanh nhất trong đó lớp Helper phức tạp và lưu trữ trong bộ nhớ heep.
tài liệu tham khảo từ "David Gassner" Đào tạo thiết yếu Java.
"int" là kiểu dữ liệu nguyên thủy và "Integer" trong Lớp Wrapper trong Java. "Số nguyên" có thể được sử dụng làm đối số cho phương thức yêu cầu một đối tượng, trong đó "int" có thể được sử dụng làm đối số cho phương thức yêu cầu giá trị nguyên, có thể được sử dụng cho biểu thức số học.
01. Số nguyên có thể là null. Nhưng int không thể là null.
Integer value1 = null; //OK
int value2 = null //Error02. Chỉ có thể truyền các giá trị loại Wrapper Class cho bất kỳ lớp bộ sưu tập nào.
(Lớp Wrapper - Boolean, Nhân vật, Byte, Ngắn, Số nguyên, Dài, Nổi, Đôi)
List<Integer> element = new ArrayList<>();
int valueInt = 10;
Integer valueInteger = new Integer(value);
element.add(valueInteger);Nhưng thông thường chúng ta thêm các giá trị nguyên thủy vào lớp bộ sưu tập? Điểm 02 có đúng không?
List<Integer> element = new ArrayList<>();
element.add(5);Có 02 là đúng, beacouse autoboxing.
Autoboxing là chuyển đổi tự động mà trình biên dịch java thực hiện giữa kiểu nguyên thủy và lớp trình bao bọc tương ứng của chúng.
Sau đó, 5 chuyển đổi thành giá trị Integer bằng cách tự động hộp.
int được xác định trước trong hàm thư viện c # nhưng trong java chúng ta có thể tạo đối tượng Integer
(Phiên bản Java) Trong các từ đơn giản int là nguyên thủy và Integer là đối tượng trình bao cho int.
Một ví dụ về nơi sử dụng Integer vs int, Khi bạn muốn so sánh và biến int một lần nữa null nó sẽ đưa ra lỗi.
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...}Trong java theo kiến thức của tôi nếu bạn học sau đó, khi bạn viết int a; sau đó trong java chung nó sẽ biên dịch mã như thế nào Integer a = new Integer(). Vì vậy, theo thuốc generic Integerkhông được sử dụng mà intđược sử dụng. Vì vậy, có sự khác biệt như vậy đó.
int là kiểu dữ liệu nguyên thủy. Integer là một lớp bao bọc. Nó có thể lưu trữ dữ liệu int dưới dạng đối tượng.
int là một kiểu dữ liệu nguyên thủy trong khi Integer là một đối tượng. Tạo một đối tượng với Integer sẽ cung cấp cho bạn quyền truy cập vào tất cả các phương thức có sẵn trong lớp Integer. Nhưng, nếu bạn tạo một kiểu dữ liệu nguyên thủy bằng int, bạn sẽ không thể sử dụng các phương thức inbuild đó và bạn phải tự xác định chúng. Nhưng, nếu bạn không muốn bất kỳ phương thức nào khác và muốn làm cho chương trình hiệu quả hơn về bộ nhớ, bạn có thể sử dụng kiểu dữ liệu nguyên thủy vì việc tạo một đối tượng sẽ làm tăng mức tiêu thụ bộ nhớ.