Pengenalan kepada Tatasusunan di Jawa

Pengaturcaraan selalunya melibatkan pengurusan dan memanipulasi set data yang besar, yang mana struktur data yang cekap dan berkesan adalah penting. Tatasusunan ialah struktur data asas dalam sains komputer dan menyediakan cara untuk menyimpan jujukan elemen saiz tetap daripada jenis yang sama. Dalam blog ini, kami akan melakukan perjalanan yang mendalam melalui tatasusunan dalam Java: memahami apa itu, sintaksnya, cara mengendalikannya dan pengurusan ingatannya.

Mengapa Kita Memerlukan Tatasusunan?

Apabila bekerja dengan pembolehubah dalam Java, anda boleh mengisytiharkan dan memulakan setiap satu secara individu, seperti:

java
int a = 19;
String name = "John Doe";

Walau bagaimanapun, pendekatan ini menjadi tidak cekap jika anda perlu mengendalikan berbilang nilai daripada jenis yang sama. Contohnya, jika anda menyimpan berbilang nombor atau nama gulungan, pengekodan keras setiap nilai tidak praktikal. Tatasusunan berguna dengan membenarkan anda menyimpan koleksi nilai dengan cekap. Contohnya, jika anda perlu menyimpan lima nombor gulungan, anda boleh menggunakan tatasusunan.

Apakah Tatasusunan?

Suatu tatasusunan pada asasnya ialah koleksi item data daripada jenis yang sama. Tatasusunan boleh menyimpan jenis data primitif seperti integer, terapung dan aksara, serta objek. Contohnya:

int[] rollNumbers = new int[5];
String[] names = {"Alice", "Bob", "Charlie"};

Sintaks Tatasusunan

Sintaks untuk mengisytiharkan tatasusunan dalam Java adalah mudah:

dataType[] arrayName = new dataType[size];

Sebagai contoh, untuk mencipta tatasusunan lima integer:

int[] rollNumbers = new int[5];

Sebagai alternatif, anda boleh mengisytiharkan dan memulakan tatasusunan dalam satu baris:

int[] rollNumbers = {23, 55, 9, 18, 45};

Ciri-ciri Tatasusunan

Unsur Homogen

Dalam tatasusunan, semua elemen mestilah daripada jenis yang sama. Anda tidak boleh mencampurkan jenis dalam satu tatasusunan; contohnya:

int[] nums = {1, 2, "three"}; // Will cause a compile-time error

Saiz Tetap

Setelah tatasusunan dibuat, saiznya ditetapkan. Anda tidak boleh mengembangkan atau mengecilkan saiznya. Kekangan ini selalunya boleh membawa kepada pemilihan struktur data lain, seperti ArrayList, untuk keperluan data yang lebih dinamik.

Pengurusan Memori Dalaman

Tatasusunan dalam Java terdiri daripada:

• Memori Tindanan: Menyimpan pembolehubah rujukan tatasusunan.
• Memori Timbunan: Menyimpan objek tatasusunan sebenar dan elemennya.

Apabila anda mengisytiharkan tatasusunan, rujukan dibuat dalam memori tindanan dan objek tatasusunan disimpan dalam memori timbunan.

Peruntukan Memori

Terdapat dua peringkat kritikal dalam peruntukan memori tatasusunan:

1. Pengisytiharan: Pembolehubah rujukan dicipta, tetapi ia tidak menghala ke mana-mana.
2. Permulaan: Pembolehubah rujukan menghala ke objek tatasusunan sebenar dalam timbunan, yang mengandungi elemen.

Contohnya:

int[] rollNumbers; // Declaration
rollNumbers = new int[5]; // Initialization

Peruntukan Memori Dinamik

Java melaksanakan peruntukan memori dinamik, bermakna pada masa jalan, ia memperuntukkan memori seperti yang diperlukan, menjadikannya cekap dalam pengurusan memori.

Input dan Output dalam Tatasusunan

Mengambil Input

Untuk mengisi tatasusunan dengan input pengguna, anda boleh menggunakan gelung bersama-sama dengan Pengimbas untuk membaca input daripada konsol.

Scanner scanner = new Scanner(System.in);
int[] arr = new int[5];
for (int i = 0; i < arr.length; i++) {
    System.out.print("Enter element " + (i + 1) + ": ");
    arr[i] = scanner.nextInt();
}

Mencetak Tatasusunan

Anda boleh mencetak tatasusunan menggunakan gelung atau kaedah utiliti Arrays.toString() untuk lebih banyak output yang boleh dibaca.

for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

atau

System.out.println(Arrays.toString(arr));

Tatasusunan Berbilang Dimensi

Tatasusunan dua dimensi, atau matriks, ialah tatasusunan tatasusunan. Sintaks untuk tatasusunan 2D kelihatan seperti ini:

int[][] matrix = new int[3][3];

Contoh

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

Untuk input dinamik elemen ke dalam tatasusunan 2D, gelung bersarang digunakan.

ArrayList: Alternatif Dinamik

Tatasusunan dalam Java adalah saiz tetap, yang membawa kepada ketidakcekapan apabila bilangan elemen tidak diketahui pada masa penyusunan. Had ini boleh diatasi dengan menggunakan kelas ArrayList, sebahagian daripada Rangka Kerja Koleksi Java.

Menggunakan ArrayList

Kelas ArrayList menyediakan saiz semula dinamik. Berikut ialah sintaks untuk mencipta ArrayList:

ArrayList<Integer> numbers = new ArrayList<>();

Anda boleh menambah dan memanipulasi elemen secara dinamik:

numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println(numbers); // Output: [1, 2, 3]

numbers.set(1, 10); // Change element at index 1
System.out.println(numbers); // Output: [1, 10, 3]

numbers.remove(0); // Remove element at index 0
System.out.println(numbers); // Output: [10, 3]

boolean contains = numbers.contains(10); // Check if the list contains 10
System.out.println(contains); // Output: true

Kerja Dalaman ArrayList

Secara dalaman, ArrayList menggunakan tatasusunan dinamik dengan kapasiti tetap awal. Apabila kapasiti ini habis, tatasusunan baharu dengan kapasiti yang lebih besar akan dicipta dan elemen sedia ada akan disalin. Proses ini memastikan ArrayList boleh berkembang secara dinamik apabila elemen ditambahkan.

Operasi Tatasusunan Biasa

Mencari Elemen Maksimum

Untuk mencari elemen maksimum dalam tatasusunan, ulangi tatasusunan dan jejaki nilai tertinggi:

int max = arr[0];
for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
}
System.out.println("Maximum value: " + max);

Membalikkan Tatasusunan

Untuk membalikkan tatasusunan, gunakan teknik dua mata:

public static void reverse(int[] arr) {
    int start = 0;
    int end = arr.length - 1;
    while (start < end) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
}

Calling the reverse function:

int[] arr = {1, 2, 3, 4, 5};
reverse(arr);
System.out.println(Arrays.toString(arr)); // Output: [5, 4, 3, 2, 1]

Conclusion

Arrays are a critical data structure in Java, enabling the storage and manipulation of data sets efficiently. While fixed in size, arrays are powerful and versatile when dealing with homogeneous data types. For dynamic data needs, ArrayList provides additional flexibility, allowing arbitrary growth in size. Understanding these structures and their operations lays the groundwork for more advanced programming and data management. Moreover, practicing array operations and understanding their underlying memory management helps in writing more efficient and optimized code.

Atas ialah kandungan terperinci Pengenalan kepada Tatasusunan di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!