Các lớp cơ sở và các cấu trúc dữ liệu trong ngôn ngữ lập trình Java

Khai báo các biến mảng

Các biến mảng có thể khai báo theo một trong hai dạng sau:

int mangInt[], bienInt; // (1)
BongDen[] dayBong, hangBong; // (2)

Tạo lập đối tượng mảng

• Để tạo lập đối tượng mảng thì phải xác định số phần tử của mảng đó và phải sử dụng toán tử new.

  <Tên mảng> = new <Kiểu các phần tử >[<Số phần tử>];

  Trong đó <Kiểu các phần tử> là kiểu tương thích với kiểu mà mảng đã khai báo.

• Giá trị cực tiểu của <Số phần tử> là 0, nghĩa là trong Java có thể tạo ra mảng 0 phần tử.

Các biến mảng khai báo ở (1), (2) có thể được tạo lập như sau:

• Nhiều khi chúng ta có thể kết hợp cả khai báo với tạo lập mảng như sau:

  <Kiểu các phần tử 1> <Tên mảng>[] = new <Kiểu các phần tử 2>[<Số phần tử>];

• Khai báo và tạo lập mảng <Tên mảng> kiểu <Kiểu các phần tử 1> để chứa <Số phầntử> các phần tử có <Kiểu các phần tử 2>.

float mangFloat[] = new float[20];// Các phần tử được gán trị mặc định

Object[] dayDen = new BongDen[5];// Các phần tử được gán mặc định  null Khởi tạo các mảng

• Java cung cấp cơ chế cho phép khai báo, tạo lập và gán ngay các giá trị ban đầu cho các phần tử của mảng:

  <Kiểu các phần tử >[] <Tên mảng> = {<Các giá trị ban đầu>};

int[] mangInt = {1, 3, 5, 7, 9};
    

 Object[] dayDT = {new BongDen(), new BongDen(), null};

 char[] charArr = {‘a’, ‘b’, ‘a’}; // mảng 3 ký tự và hoàn toàn khác với "aba"

Sử dụng mảng

Toàn bộ cấu trúc mảng được tham chiếu thông qua tên của mảng, còn các phần tử của nó có thể truy nhập được bởi toán tử [].Chỉ số các phần tử của mảng nhỏ nhất là 0 và nhỏ hơn kích thước của nó là <Tên mảng>.length. Phần tử thứ i của mảng là phần tử có chỉ số i - 1(<Tên mảng>[i-1]).

Ví dụ 4 Mô tả cách tạo ra năm mảng 15 các phần tử ngẫu nhiên và lưu lại năm giá trị cực tiểu của chúng để in ra màn hình.

class Mang {
    public static void main(String args[]){
    	// Khai báo và tạo lập mảng
    	double[] mang1 = new double[5]; // (1)
    	double[] mang2 = new double[15]; // (2)
    	for(int j = 0; j < mang1.length; ++j){ // (3)
    	randomize(mang2); // Tạo lập mảng ngẫu nhiên
    	mang1[j] = cucTieu(mang2); // Tìm giá trị cực tiểu
    }
   	 // In các giá trị cực tiểu ra màn hình // (4)
    	for(int j = 0; j < mang1.length; ++j){
    	System.out.println(mang1[j]);
    }
    }
    public static void randomize(double[] mang){ // (5)
    	for(int j = 0; j < mang.length; ++j)
    	mang[j] = Math.random() * 100.0;
    }
    public static double cucTieu(double[] mang){// (6)
   	 double giaTriMin = mang[0];
    	for(int j = 0; j < mang1.length; ++j)
    	giaTriMin = Math.min(giaTriMin, mang[j]);
    	return giaTriMin;
    }
    }
    

Mảng nhiều chiều

Các phần tử của mảng có thể tham chiếu tới các mảng khác. Trong Java, mảng của mảng (mảng nhiều chiều) được định nghĩa như sau:

hoặc

Toán tử [] có thể sử dụng ở cả hai vị trí,

 
int[][] mang1; // Mảng hai chiều tương đương với
int mang1[][]; và cũng tương đương với
int[] mang1[]; Thông thường chúng ta có thể kết hợp cả khai báo với thiết lập mảng nhiều chiều tương tự như đối với mảng đơn.
int[][] mangA = new int[4][5]; // Ma trận có 4 hàng, 5 cột
    

Như thế mảng hai chiều còn được gọi là mảng của mảng. Phần tử thứ j của mangA[i], j = 1, 2, ..., 5 được truy nhập bởi mangA[i][j]. Do vậy, kích thước của mangA là mangA.length = 4 và mỗi phần tử của nó lại là mảng có kích thước là mangA[i].length = 5, i = 1, 2, ..., 4.

double[][] maTran = {

{1, 2, 3, 4}, // hàng 1

{0, 2, 0, 0}, // hàng 2

{0, 0, 3, 0}, // hàng 3

{0, 0, 0, 4}, // hàng 4

};

BongDen[][] dayDen = {
    	{new BongDen(),null,new BongDen()},// Hàng có 3 phần tử (1)
    	{null, new BongDen()}, // Hàng có 2 phần tử (2)
    	{}, // Hàng có 0 phần tử (3)
    	{new BongDen()}, // Hàng có 3 phần tử (4)
    	{null} // Hàng chưa được tạo lập (5)
    };
    

class EpKieu{
    static public void main(String[] args){
    	int[] a = new int[5];
   	 Object o;
    	o = a; // int[] là con của Object
    	int[] b = new int[5];
    	b = (int[])o; // Xem đối tượng của Object như là mảng int[]
    }
    }
    

Ngoài ra cũng cần lưu ý thêm là cấu trúc mảng bảo toàn cấu trúc phân cấp giữa các lớp, nghĩa là nếu B là lớp con của lớp A thì B[] cũng là lớp con của lớp A[].

Lớp Object

Tất cả các lớp được xây dựng trong các chương trình Java đều hoặc là trực tiếp hoặc gián tiếp là mở rộng của Object. Đây là lớp cơ sở nhất, định nghĩa hầu như tất cả những hàm thành phần cơ sở để các lớp con cháu của nó sử dụng trực tiếp hoặc viết đè như đã đề cập ở chương 3.

Object cung cấp các hàm sau:

• int hashCode() Khi các đối tượng được lưu vào các bảng băm (hash table), hàm này có thể sử dụng để xác định duy nhất giá trị cho mỗi đối tượng. Điều này đảm bảo tính nhất quán của hệ thống khi thực hiện chương trình.
• Class getClass() Trả lại tên lớp của đối tượng hiện thời.
• boolean equals(Object obj) Cho lại kết quả true khi đối tượng hiện thời và obj là cùng một đối tượng. Hàm này thường được viết đè ở các lớp con cho phù hợp với ngữ cảnh so sánh bằng nhau trong các lớp mở rộng đó.
• protected Object clone() throws CloneNotSupportedException Đối tượng mới được tạo ra có cùng các trạng thái như đối tượng hiện thời khi sử dụng clone(), nghĩa là tạo ra bản copy mới của đối tượng hiện thời.
• String toString() Nếu các lớp con không viết đè hàm này thì nó sẽ trả lại dạng biểu diễn văn bản (textual) của đối tượng. Hàm println() ở lớp PrintStream sẽ chuyển các đối số của nó sang dạng văn bản khi sử dụng hàm toString().
• protected void finalize() throws Throwable Hàm này được gọi ngay trước khi đối tượng bị dọn vào “thùng rác”, nghĩa là trước khi đối tượng đó bị huỷ bỏ.

Các lớp nguyên thủy (Wrapper)

Các giá trị nguyên thủy không phải là đối tượng trong Java. Để có thể thao tác được trên các giá trị nguyên thủy (giá trị số và giá trị logic) thì gói java.lang cung cấp các lớp bao gói (Wrapper) cho từng kiểu dữ liệu nguyên thủy (gọi tắt là lớp nguyên thủy). Các lớp nguyên thủy có những đặc tính chung sau:

• Các toán tử tạo lập chung. Các lớp nguyên thủy (trừ lớp Character chỉ có một toán tử tạo lập) đều có hai toán tử tạo lập: Toán tử tạo lập sử dụng giá trị nguyên thủy để tạo ra đối tượng tương ứng

• Character charObj = new Character(‘a’);

• Boolean boolObj = new Boolean(true);

• Integer intObj = new Integer(2002);

• Float floatObj = new Float(3.14F);

• Double doubleObj = new Double(3.14);

• Toán tử thứ hai: chuyển các đối tượng lớp String biểu diễn cho các giá trị nguyên thủy về các lớp tương ứng. Các toán tử này sẽ cho qua NumberFormatException khi tham biến kiểu String không hợp lệ.

• Boolean boolObj = new Boolean("true");

• Integer intObj = new Integer("2002");

• Float floatObj = new Float("3.14F");

• Double doubleObj= new Double("3.14");

Có các hàm tiện ích chung: valueOf(String s), toString(), typeValue(), equals().

• Mỗi lớp (trừ lớp Character) đều định nghĩa hàm static valueOf(String s) trả lại đối tượng tương ứng. Các hàm này đều cho qua NumberFormatException khi tham biến kiểu String không hợp lệ.

Boolean boolObj = Boolean.valueOf("true");
    Integer intObj = Integer.valueOf("2002");
    Float floatObj = Float.valueOf(“3.14F”);
    Double doubleObj= Double.valueOf("3.14");
    

• Các lớp viết đè hàm toString() trả lại là các đối tượng String biểu diễn cho các giá trị nguyên thủy ở dạng xâu.

String charStr = charObj.toString(); // "a"
    String boolStr = boolObj.toString(); // "true"
    String intStr = intObj.toString(); // "2002"
    String doubleStr = doubleObj.toString(); // "3.14"
    

• Các lớp định nghĩa hàm typeValue() trả lại các giá trị nguyên thủy tương ứng với các đối tượng nguyên thủy.

boolean b = boolObj.charValue(); // true
    int i = intObj.intValue(); // 2002
    float f = floatObj.floatValueOf(); // 3.14F
    double d = doubleObj.doubleValueOf(); // 3.14
    char c = charObj.charValue(); // ‘a’
    

• Các lớp viết đè hàm equals() để thực hiện so sánh bằng nhau của các đối tượng nguyên thủy.

Character charObj = new Character(‘a’);
    boolean charTest = charObj.equals(‘b’); // false
    Integer intObj1 = Integer.valueOf("2010");
    boolean intTest = intObj.equals(intObj1); // false
    

Lớp Boolean

Lớp Character

Lớp Character định nghĩa hai giá trị cực tiểu, cực đại Character.MIN_VALUE, Character.MAX_VALUE và các giá trị kiểu ký tự Unicode. Ngoài ra lớp này còn định nghĩa một số hàm static để xử lý trên các ký tự:

• static boolean isLowerCase(char ch)// true nếu ch là ký tự thường
• static boolean isUpperCase(char ch)// true nếu ch là ký tự viết hoa
• static boolean isDigit(char ch) // true nếuch là chữ số
• static boolean isLetter(char ch)// true nếu ch là chữ cái
• static boolean isLetterOrDigit(char ch) // true nếu ch là chữ hoặc là số
• static char toUpperCase(char ch)// Chuyển ch về chữ viết hoa
• static char toLowerCase(char ch)// Chuyển ch về chữ viết thường
• static char toTitleCase(char ch)// Chuyển ch về dạng tiêu đề.

Các lớp nguyên thủy

• Các lớp Byte, Short, Integer, Long, Float, Double là các lớp con của lớp Number. Trong các lớp này đều xác định hai giá trị:
• <Lớp nguyên thủy>.MIN_VALUE
• <Lớp nguyên thủy>.MAX_VALUE
• là các giới hạn của các số trong kiểu đó.

• byte minByte = Byte.MIN_VALUE; // -128

• int maxInt = Integer.MAX_VALUE; // 2147483647