Dữ liệu nguyên thủy (Primitive Data Types) là các kiểu dữ liệu được Java cung cấp sẵn cho chúng ta sử dụng. Trong Java 8 có các kiểu dữ liệu cơ bản sau: byte, short, int, long, char, boolean, float, và double.
Ta sẽ lần lượt điểm qua về các kiểu dữ liệu này.
[toc]
char
Kiểu char dùng để chứa 1 ký tự đơn dạng Unicode 16 bit. Ký tự này được chứa trong cặp dấu nháy đơn. Ví dụ:
char myChar = 'u'; char myChar2 = '5'; char myChar3 = 65; // myChar3 == 'A'
Lưu ý: char chỉ được dùng để lưu trữ ký tự đơn. Không có chuyện:
char myChar = 'xyz';
Giá trị nhỏ nhất của 1 biến kiểu Char là 0 (2^0-1) và giá trị lớn nhất của biến char là 65535 (2^16-1).
Để biểu diễn ký tự nháy đơn. Ta làm như thế này:
char singleBlock = '\'';
Biểu diễn các ký tự đặc biệt khác dưới dạng char:
char tab = '\t'; char backspace = '\b'; char newline = '\n'; char carriageReturn = '\r'; char formfeed = '\f'; char singleQuote = '\''; //dấu nháy đơn char doubleQuote = '\"'; //dấu nháy kép char unicodeChar = '\uXXXX' // XXXX là mã ký tự trong bảng mã Unicode
Bạn có thể biểu diễn bất cứ ký tự nào trong bảng mã unicode bằng kiểu dữ liệu char:
char heart = '\u2764'; System.out.println(Character.toString(heart)); // in ra "❤"
float
Kiểu dữ liệu Float sử dụng để biểu diễn các số thực 32 bit. Mặc định trong Java, 1 số thực sẽ được hiểu là mang kiểu Double, vì vậy khai báo biến Float ta cần thêm hậu tố f vào sau giá trị biến. Ví dụ:
double doubleExample = 0.5; // không có hậu tố f, => kiểu double float floatExample = 0.5f; // có hậu tố f, => kiểu float float myFloat = 92.7f; // 1 biến kiểu float float positiveFloat = 89.3f; // biến float mang giá trị dương float negativeFloat = -89.3f; // biến float mang giá trị âm float integerFloat = 43.0f; // biến float có thể mang giá trị của 1 số nguyên (nhưng nó không phải int)
1 biến Kiểu dữ liệu Float có thể sử dụng các toán tử cộng, trừ nhân chia và lấy module:
// cộng float result = 37.2f + -2.6f; // result: 34.6 // trừ float result = 45.1f - 10.3f; // result: 34.8 // nhân float result = 26.3f * 1.7f; // result: 44.71 GoalKicker.com – Java® Notes for Professionals 76 // chia float result = 37.1f / 4.8f; // result: 7.729166 // phần dư float result = 37.1f % 4.8f; // result: 3.4999971
Lưu ý:
- Lưu ý: : Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.NaN là những giá trị biểu diễn cho dương vô cùng, âm vô cùng, và not a number.
- Float.NaN biểu diễn cho kết quả của những phép tính không thể xác định giá trị, vd như phép chia của 2 giá trị vô cùng. Ví dụ:
System.out.println(1f / 0f); // dương vô cùng System.out.println(1f / -0f); // âm vô cùng System.out.println(Float.POSITIVE_INFINITY / Float.POSITIVE_INFINITY); // NaN (not a number)
int
int biểu diễn các giá trị nguyên 32 bit (các giá trị nằm trong khoảng -(2^32)+1 và 2^32-1. Ví dụ:
int example = -42; int myInt = 284; int anotherInt = 73; int addedInts = myInt + anotherInt; // 284 + 73 = 357 int subtractedInts = myInt - anotherInt; // 284 - 73 = 211
Nếu ta cần biểu diễn những giá trị ngoài khoảng Int, ta cần sử dụng kiểu dữ liệu long.
Các giá trị lớn nhất và nhỏ nhất của int:
nt high = Integer.MAX_VALUE; // GTLN == 2147483647 int low = Integer.MIN_VALUE; // GTNN == -2147483648
Giá trị mặc định của int là 0:
int defaultInt; // defaultInt == 0;
double
Tương tự như float, double biểu diễn kiểu số thực. Nhưng vùng giá trị của double lớn hơn float. Double biểu diễn cho kiểu số thực 64 bit. Mặc định 1 số thực sẽ được Java hiểu là kiểu double. Ta có thể định nghĩa 1 số thực như sau:
double example = -7162.37; //Mặc định số thực được hiểu là double double myDouble = 974.21d; //Có thể thêm hậu tố d vào sau giá trị double anotherDouble = 658.7; double addedDoubles = myDouble + anotherDouble; // 315.51 double subtractedDoubles = myDouble - anotherDouble; // 1632.91 double scientificNotationDouble = 1.2e-3; // 0.0012
Giá trị mặc định của double là 0.
public double defaultDouble; // defaultDouble == 0.0
Lưu ý:
- Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NaN là những giá trị biểu diễn cho dương vô cùng, âm vô cùng, và not a number.
- Double.NaN biểu diễn cho kết quả của những phép tính không thể xác định giá trị, vd như phép chia của 2 giá trị vô cùng. Ví dụ:
System.out.println(1f / 0d); // Dương vô cùng System.out.println(1f / -0d); // Âm vô cùng System.out.println(Float.POSITIVE_INFINITY / Float.POSITIVE_INFINITY); // NaN (not a number)
long
long biểu diễn các giá trị nguyên 64 bit (các giá trị nằm trong khoảng -(2^64)+1 và 2^64-1. Ví dụ:
long example = -42L; long myLong = 284L; long anotherLong = 73L; //Trong java 1 số nguyên mặc định được hiểu là có kiểu int //1 số nguyên lớn, ví dụ như 549755813888 (2 ^ 39), lớn hơn giá trị max của // kiểu int (2^31 - 1), bắt buộc phải thêm hậu tố L long bigNumber = 549755813888L; long addedLongs = myLong + anotherLong; // 284 + 73 = 357 long subtractedLongs = myLong - anotherLong; // 284 - 73 = 211
Các giá trị lớn nhất và nhỏ nhất của long:
long high = Long.MAX_VALUE; // high == 9223372036854775807L long low = Long.MIN_VALUE; // low == -9223372036854775808L
Giá trị mặc định của long là 0:
long defaultLong; // defaultLong == 0L
Chú ý:
Dù ta khai báo kiểu long, nhưng với những biến có giá trị nằm trong khoảng -127 đến 127, biến đó vẫn mang giá trị của 1 đối tượng Integer. Ví dụ:
Long val1 = 127L; Long val2 = 127L; System.out.println(val1 == val2); // true Long val3 = 128L; Long val4 = 128L; System.out.println(val3 == val4); // false
Để so sánh chính xác 2 biến long, ta cần làm như sau:
Long val3 = 128L; Long val4 = 128L; System.out.println(Objects.equal(val3, val4)); // true
Lúc này kết quả so sánh đã mang giá trị true.
boolean
1 biến kiểu boolean chứa 1 trong 2 giá trị true hoặc false:
boolean foo = true;
System.out.println("foo = " + foo); // foo = true
boolean bar = false;
System.out.println("bar = " + bar); // bar = false
boolean notFoo = !foo;
System.out.println("notFoo = " + notFoo); // notFoo = false
boolean fooAndBar = foo && bar;
System.out.println("fooAndBar = " + fooAndBar); // fooAndBar = false
boolean fooOrBar = foo || bar;
System.out.println("fooOrBar = " + fooOrBar); // fooOrBar = true
boolean fooXorBar = foo ^ bar;
System.out.println("fooXorBar = " + fooXorBar); // fooXorBar = true
Giá trị mặc định của boolean là false.
byte
byte biểu diễn số nguyên 8 bit nằm trong khoảng -128 đến 127.
byte example = -36; byte myByte = 96; byte anotherByte = 7; byte addedBytes = (byte) (myByte + anotherByte); // 103 byte subtractedBytes = (byte) (myBytes - anotherByte); // 89
Giá trị lớn nhất và nhỏ nhất của byte:
byte high = Byte.MAX_VALUE; // high == 127 byte low = Byte.MIN_VALUE; // low == -128
Giá trị mặc định của byte là 0:
byte defaultByte; // defaultByte == 0
short
short biểu diễn giá trị nguyên trong khoảng -32768 đến 32767
short example = -48; short myShort = 987; short anotherShort = 17; short addedShorts = (short) (myShort + anotherShort); // 1,004 short subtractedShorts = (short) (myShort - anotherShort); // 970
Giá trị lớn nhất và nhỏ nhất của short:
short high = Short.MAX_VALUE; // high == 32767 short low = Short.MIN_VALUE; // low == -32768
Giá trị mặc định của short là 0:
short defaultShort; // defaultShort == 0