Array di Jawa: Panduan Referensi

1. Perkenalan

Dalam tutorial ini, kita akan mendalami konsep inti dalam bahasa Java - array.

Pertama-tama kita akan melihat apa itu array, lalu bagaimana menggunakannya; secara keseluruhan, kami akan membahas cara:

  • Mulailah dengan array
  • Membaca dan menulis elemen array
  • Ulangi array
  • Ubah array menjadi objek lain seperti List atau Streams
  • Urutkan, cari, dan gabungkan array

2. Apa itu Array?

Hal pertama yang pertama, kita perlu mendefinisikan apa itu array? Menurut dokumentasi Java, array adalah objek yang berisi sejumlah nilai tetap dari tipe yang sama . Elemen-elemen array diindeks, yang berarti kita dapat mengaksesnya dengan angka (disebut indeks ).

Kita dapat menganggap sebuah array sebagai daftar sel bernomor, setiap sel menjadi variabel yang memiliki nilai. Di Jawa, penomoran dimulai dari 0.

Ada array tipe primitif dan array tipe objek. Ini berarti kita bisa menggunakan array int, float, boolean,… Tapi juga array dari String, Object dan custom.

3. Menyiapkan Array

Sekarang array sudah terdefinisi dengan baik, mari selami penggunaannya.

Kami akan membahas banyak topik yang mengajari kami cara menggunakan array. Kita akan mempelajari beberapa dasar seperti cara mendeklarasikan dan menginisialisasi array, tetapi kita juga akan membahas subjek yang lebih canggih seperti menyortir dan mencari array.

Mari kita pergi dulu dengan deklarasi dan inisialisasi.

3.1. Pernyataan

Kami akan mulai dengan deklarasi. Ada dua cara untuk mendeklarasikan array di Java:

int[] anArray;

atau:

int anOtherArray[];

Yang pertama lebih banyak digunakan daripada yang terakhir .

3.2. Inisialisasi

Sekarang saatnya untuk melihat bagaimana menginisialisasi array. Sekali lagi, ada banyak cara untuk menginisialisasi sebuah array. Kita akan melihat yang utama di sini, tetapi artikel ini membahas inisialisasi array secara detail.

Mari kita mulai dengan cara sederhana:

int[] anArray = new int[10];

Dengan menggunakan metode ini, kami menginisialisasi array sepuluh elemen int . Perhatikan bahwa kita perlu menentukan ukuran array.

Saat menggunakan metode ini, kami menginisialisasi setiap elemen ke nilai defaultnya , di sini 0 . Saat menginisialisasi larik Objek , elemen bernilai null secara default.

Sekarang kita akan melihat cara lain yang memberi kita kemungkinan untuk mengatur nilai ke array secara langsung saat membuatnya:

int[] anArray = new int[] {1, 2, 3, 4, 5};

Di sini, kami menginisialisasi lima elemen array yang berisi angka 1 sampai 5. Saat menggunakan metode ini kami tidak perlu menentukan panjang array, itu adalah jumlah elemen yang kemudian dideklarasikan di antara tanda kurung.

4. Mengakses Elemen

Sekarang mari kita lihat bagaimana mengakses elemen dari sebuah array. Kita dapat mencapai ini dengan membutuhkan posisi sel array.

Misalnya, potongan kode kecil ini akan mencetak 10 ke konsol:

anArray[0] = 10; System.out.println(anArray[0]);

Perhatikan bagaimana kami menggunakan indeks untuk mengakses sel array. Angka di antara tanda kurung adalah posisi spesifik dari larik yang ingin kita akses.

Saat mengakses sel, jika indeks yang diteruskan negatif atau melampaui sel terakhir, Java akan menampilkan ArrayIndexOutOfBoundException .

Kita harus berhati-hati agar tidak menggunakan indeks negatif, atau indeks lebih besar dari atau sama dengan ukuran array .

5. Iterasi Selama Array

Mengakses elemen satu per satu bisa berguna, tetapi kita mungkin ingin mengulang melalui array. Mari kita lihat bagaimana kita bisa mencapai ini.

Cara pertama adalah menggunakan for loop:

int[] anArray = new int[] {1, 2, 3, 4, 5}; for (int i = 0; i < anArray.length; i++) { System.out.println(anArray[i]); }

Ini harus mencetak nomor 1 hingga 5 ke konsol. Seperti yang bisa kita lihat, kita memanfaatkan properti panjang . Ini adalah properti publik yang memberi kita ukuran array.

Tentu saja, dimungkinkan untuk menggunakan mekanisme perulangan lain seperti while atau do while . Tapi, untuk koleksi Java, dimungkinkan untuk mengulang array menggunakan foreach loop:

int[] anArray = new int[] {1, 2, 3, 4, 5}; for (int element : anArray) { System.out.println(element); }

Contoh ini setara dengan yang sebelumnya, tetapi kami menyingkirkan kode boilerplate indeks. The foreach loop pilihan ketika:

  • kita tidak perlu memodifikasi array (meletakkan nilai lain dalam elemen tidak akan mengubah elemen dalam array)
  • kami tidak membutuhkan indeks untuk melakukan hal lain

6. Varargs

Kami telah membahas dasar-dasar dalam hal pembuatan dan manipulasi array. Sekarang, kita akan menyelami topik yang lebih maju, dimulai dengan vararg . Sebagai pengingat, vararg digunakan untuk meneruskan sejumlah argumen ke suatu metode:

void varargsMethod(String... varargs) {}

Metode ini dapat menggunakan 0 hingga sejumlah argumen String . Artikel yang meliput vararg dapat ditemukan di sini.

What we have to know here is that inside the method body, a varargs parameter turns into an array. But, we can also pass an array directly as the argument. Let's see how by reusing the example method declared above:

String[] anArray = new String[] {"Milk", "Tomato", "Chips"}; varargsMethod(anArray);

Will behave the same as:

varargsMethod("Milk", "Tomato", "Chips");

7. Transforming an Array into a List

Arrays are great, but sometimes it can be handier to deal with List instead. We'll see here how to transform an array into a List.

We'll first do it the naïve way, by creating an empty list and iterating over the array to add its elements to the list:

int[] anArray = new int[] {1, 2, 3, 4, 5}; List aList = new ArrayList(); for (int element : anArray) { aList.add(element); }

But there is another way, a little bit more succinct:

Integer[] anArray = new Integer[] {1, 2, 3, 4, 5}; List aList = Arrays.asList(anArray);

The static method Arrays.asList takes a varargs argument and creates a list with the passed values. Unfortunately, this method comes with some drawbacks:

  • It's not possible to use an array of primitive types
  • We can't add or remove elements from the created list, as it'll throw an UnsupportedOperationException

8. From an Array to a Stream

We can now transform arrays into lists, but since Java 8 we have access to the Stream API and we might want to turn our arrays into Stream. Java provides us with the Arrays.stream method for that:

String[] anArray = new String[] {"Milk", "Tomato", "Chips"}; Stream aStream = Arrays.stream(anArray);

When passing an Object array to the method it will return a Stream of the matching type (e.g. Stream for an array of Integer). When passing a primitive one it will return the corresponding primitive Stream.

It's also possible to create the stream only on a subset of the array:

Stream anotherStream = Arrays.stream(anArray, 1, 3);

This will create a Stream with only “Tomato” and “Chips” Strings (the first index being inclusive while the second one is exclusive).

9. Sorting Arrays

Let's now see how to sort an array, that is rearranging its elements in a certain order. The Arrays class provides us with the sort method. A bit like the stream method, sort has a lot of overloadings.

There are overloadings to sort:

  • Primitive type arrays: which are sorted in ascending order
  • Object arrays (those Object must implement the Comparable interface): which are sorted according to the natural order (relying on the compareTo method from Comparable)
  • Generic arrays: which are sorted according to a given Comparator

In addition, it's possible to sort only a specific portion of an array (passing start and end indices to the method).

The algorithms behind the sort method are quick sort and merge sort for primitive and other arrays, respectively.

Let's see how this all work through some examples:

int[] anArray = new int[] {5, 2, 1, 4, 8}; Arrays.sort(anArray); // anArray is now {1, 2, 4, 5, 8} Integer[] anotherArray = new Integer[] {5, 2, 1, 4, 8}; Arrays.sort(anotherArray); // anotherArray is now {1, 2, 4, 5, 8} String[] yetAnotherArray = new String[] {"A", "E", "Z", "B", "C"}; Arrays.sort(yetAnotherArray, 1, 3, Comparator.comparing(String::toString).reversed()); // yetAnotherArray is now {"A", "Z", "E", "B", "C"}

10. Searching in an Array

Searching an array is pretty simple, we can loop over the array and search our element among the array elements:

int[] anArray = new int[] {5, 2, 1, 4, 8}; for (int i = 0; i < anArray.length; i++) { if (anArray[i] == 4) { System.out.println("Found at index " + i); break; } }

Here we searched for number 4 and found it at index 3.

If we have a sorted array though, we can use another solution: the binary search. The principle of binary search is explained in this article.

Fortunately, Java provides us with the Arrays.binarySearch method. We have to give it an array and an element to search.

In case of a generic array, we also have to give it the Comparator that was used to sort the array in the first place. There is again the possibility to call the method on a subset of the array.

Let's see an example of the binary search method usage:

int[] anArray = new int[] {1, 2, 3, 4, 5}; int index = Arrays.binarySearch(anArray, 4); System.out.println("Found at index " + index);

As we stored number 4 in the fourth cell, this will return index 3 as the result. Note that we used an already sorted array.

11. Concatenating Arrays

Finally, let's see how to concatenate two arrays. The idea is to create an array which length is the sum of the two arrays to concatenate. After that we have to add the elements of the first one and then the elements of the second one:

int[] anArray = new int[] {5, 2, 1, 4, 8}; int[] anotherArray = new int[] {10, 4, 9, 11, 2}; int[] resultArray = new int[anArray.length + anotherArray.length]; for (int i = 0; i < resultArray.length; i++) { resultArray[i] = (i < anArray.length ? anArray[i] : anotherArray[i - anArray.length]); }

As we can see, when the index is still lesser than the first array length we add elements from that array. Then we add elements from the second one. We can make use of the Arrays.setAll method to avoid writing a loop:

int[] anArray = new int[] {5, 2, 1, 4, 8}; int[] anotherArray = new int[] {10, 4, 9, 11, 2}; int[] resultArray = new int[anArray.length + anotherArray.length]; Arrays.setAll(resultArray, i -> (i < anArray.length ? anArray[i] : anotherArray[i - anArray.length]));

This method will set all array element according to the given function. This function associates an index with a result.

Berikut adalah opsi ketiga untuk menggabungkan ke array: System.arraycopy . Metode ini mengambil larik sumber , posisi sumber, larik tujuan , posisi tujuan dan int yang menentukan jumlah elemen yang akan disalin:

System.arraycopy(anArray, 0, resultArray, 0, anArray.length); System.arraycopy(anotherArray, 0, resultArray, anArray.length, anotherArray.length);

Seperti yang bisa kita lihat, kita menyalin array pertama, lalu yang kedua (setelah elemen terakhir dari yang pertama).

12. Kesimpulan

Dalam artikel mendetail ini kita telah membahas dasar dan beberapa penggunaan array tingkat lanjut di Java.

Kami melihat bahwa Java menawarkan banyak metode untuk menangani array melalui kelas utilitas Array . Ada juga kelas utilitas untuk memanipulasi array di perpustakaan seperti Apache Commons atau Guava.

Kode lengkap untuk artikel ini dapat ditemukan di GitHub kami.