Operasi Array di Java

1. Ikhtisar

Setiap pengembang Java tahu bahwa menghasilkan solusi yang bersih dan efisien saat bekerja dengan operasi array tidak selalu mudah dicapai. Tetap saja, mereka adalah bagian utama dalam ekosistem Java - dan kita harus menanganinya dalam beberapa kesempatan.

Untuk alasan ini, ada baiknya memiliki 'lembar sontekan' - ringkasan prosedur paling umum untuk membantu kita menyelesaikan teka-teki dengan cepat. Tutorial ini akan berguna dalam situasi tersebut.

2. Array dan Kelas Helper

Sebelum melanjutkan, ada baiknya untuk memahami apa itu array di Java, dan bagaimana menggunakannya. Jika ini pertama kalinya Anda mengerjakannya di Java, kami sarankan untuk melihat posting sebelumnya di mana kami membahas semua konsep dasar.

Harap dicatat bahwa operasi dasar yang didukung oleh array, dalam beberapa hal, terbatas. Tidak jarang melihat algoritma yang kompleks untuk menjalankan tugas yang relatif sederhana dalam hal array.

Untuk alasan ini, untuk sebagian besar operasi kita, kita akan menggunakan kelas dan metode pembantu untuk membantu kita: kelas Array yang disediakan oleh Java dan ArrayUtils Apache .

Untuk memasukkan yang terakhir dalam proyek kita, kita harus menambahkan ketergantungan Apache Commons:

 org.apache.commons commons-lang3 3.8.1 

Kami dapat melihat versi terbaru artefak ini di Maven Central.

3. Dapatkan Elemen Pertama dan Terakhir dari sebuah Array

Ini adalah salah satu tugas yang paling umum dan sederhana berkat sifat array yang diakses oleh indeks.

Mari kita mulai dengan mendeklarasikan dan menginisialisasi array int yang akan digunakan di semua contoh kita (kecuali kita menentukan sebaliknya):

int[] array = new int[] { 3, 5, 2, 5, 14, 4 };

Mengetahui bahwa item pertama dari sebuah array dikaitkan dengan nilai indeks 0 dan memiliki atribut panjang yang dapat kita gunakan, maka mudah untuk mengetahui bagaimana kita bisa mendapatkan dua elemen ini:

int firstItem = array[0]; int lastItem = array[array.length - 1];

4. Dapatkan Nilai Acak dari Array

Dengan menggunakan objek java.util.Random kita bisa dengan mudah mendapatkan nilai apapun dari array kita:

int anyValue = array[new Random().nextInt(array.length)];

5. Tambahkan Item Baru ke Array

Seperti yang kita ketahui, array memiliki ukuran nilai yang tetap. Oleh karena itu, kami tidak bisa hanya menambahkan item dan melebihi batas ini.

Kita harus mulai dengan mendeklarasikan array baru yang lebih besar, dan menyalin elemen dari array dasar ke yang kedua.

Untungnya, kelas Array menyediakan metode praktis untuk mereplikasi nilai larik ke struktur baru dengan ukuran berbeda:

int[] newArray = Arrays.copyOf(array, array.length + 1); newArray[newArray.length - 1] = newItem;

Secara opsional, jika kelas ArrayUtils dapat diakses dalam proyek kita, kita dapat menggunakan metode add -nya (atau alternatif addAll -nya ) untuk mencapai tujuan kita dalam pernyataan satu baris:

int[] newArray = ArrayUtils.add(array, newItem);

Seperti yang bisa kita bayangkan, metode ini tidak mengubah objek array asli ; kita harus menetapkan outputnya ke variabel baru.

6. Sisipkan Nilai Antara Dua Nilai

Karena karakter nilai indeksnya, memasukkan item dalam array di antara dua lainnya bukanlah pekerjaan yang sepele.

Apache menganggap ini skenario tipikal dan menerapkan metode di kelas ArrayUtils untuk menyederhanakan solusi:

int[] largerArray = ArrayUtils.insert(2, array, 77);

Kita harus menentukan indeks di mana kita ingin memasukkan nilainya, dan hasilnya adalah array baru yang berisi lebih banyak elemen.

Argumen terakhir adalah argumen variabel (alias vararg ) sehingga kita dapat memasukkan sejumlah item dalam array.

7. Bandingkan Dua Array

Meskipun array adalah Objek dan oleh karena itu menyediakan metode yang sama , mereka menggunakan implementasi defaultnya, hanya mengandalkan persamaan referensi.

Kami bagaimanapun dapat memanggil java.util.Arrays ' sama metode untuk memeriksa apakah dua objek array yang berisi nilai-nilai yang sama:

boolean areEqual = Arrays.equals(array1, array2);

Note: this method is not effective for jagged arrays. The appropriate method to verify multi-dimensional structures' equality is the Arrays.deepEquals one.

8. Check if an Array Is Empty

This is an uncomplicated assignment having in mind that we can use the length attribute of arrays:

boolean isEmpty = array == null || array.length == 0;

Moreover, we also have a null-safe method in the ArrayUtils helper class that we can use:

boolean isEmpty = ArrayUtils.isEmpty(array);

This function still depends on the length of the data structure, which considers nulls and empty sub-arrays as valid values too, so we'll have to keep an eye on these edge cases:

// These are empty arrays Integer[] array1 = {}; Integer[] array2 = null; Integer[] array3 = new Integer[0]; // All these will NOT be considered empty Integer[] array3 = { null, null, null }; Integer[][] array4 = { {}, {}, {} }; Integer[] array5 = new Integer[3];

9. How to Shuffle the Elements of an Array

In order to shuffle the items in an array, we can use the ArrayUtil‘s feature:

ArrayUtils.shuffle(array);

This is a void method and operates on the actual values of the array.

10. Box and Unbox Arrays

We often come across methods that support only Object-based arrays.

Again the ArrayUtils helper class comes in handy to get a boxed version of our primitive array:

Integer[] list = ArrayUtils.toObject(array);

The inverse operation is also possible:

Integer[] objectArray = { 3, 5, 2, 5, 14, 4 }; int[] array = ArrayUtils.toPrimitive(objectArray);

11. Remove Duplicates from an Array

The easiest way of removing duplicates is by converting the array to a Set implementation.

As we may know, Collections use Generics and hence don't support primitive types.

For this reason, if we're not handling object-based arrays as in our example, we'll first need to box our values:

// Box Integer[] list = ArrayUtils.toObject(array); // Remove duplicates Set set = new HashSet(Arrays.asList(list)); // Create array and unbox return ArrayUtils.toPrimitive(set.toArray(new Integer[set.size()]));

Note: we can use other techniques to convert between an array and a Set object as well.

Also, if we need to preserve the order of our elements, we must use a different Set implementation, such as a LinkedHashSet.

12. How to Print an Array

Same as with the equals method, the array's toString function uses the default implementation provided by the Object class, which isn't very useful.

Both Arrays and ArrayUtils classes ship with their implementations to convert the data structures to a readable String.

Apart from the slightly different format they use, the most important distinction is how they treat multi-dimensional objects.

The Java Util's class provides two static methods we can use:

  • toString: doesn't work well with jagged arrays
  • deepToString: supports any Object-based arrays but doesn't compile with primitive array arguments

On the other hand, Apache's implementation offers a single toString method that works correctly in any case:

String arrayAsString = ArrayUtils.toString(array);

13. Map an Array to Another Type

It's often useful to apply operations on all array items, possibly converting them to another type of object.

With this objective in mind, we'll try to create a flexible helper method using Generics:

public static  U[] mapObjectArray( T[] array, Function function, Class targetClazz) { U[] newArray = (U[]) Array.newInstance(targetClazz, array.length); for (int i = 0; i < array.length; i++) { newArray[i] = function.apply(array[i]); } return newArray; }

If we don't use Java 8 in our project, we can discard the Function argument, and create a method for each mapping that we need to carry out.

We can now reuse our generic method for different operations. Let's create two test cases to illustrate this:

@Test public void whenMapArrayMultiplyingValues_thenReturnMultipliedArray() { Integer[] multipliedExpectedArray = new Integer[] { 6, 10, 4, 10, 28, 8 }; Integer[] output = MyHelperClass.mapObjectArray(array, value -> value * 2, Integer.class); assertThat(output).containsExactly(multipliedExpectedArray); } @Test public void whenMapDividingObjectArray_thenReturnMultipliedArray() { Double[] multipliedExpectedArray = new Double[] { 1.5, 2.5, 1.0, 2.5, 7.0, 2.0 }; Double[] output = MyHelperClass.mapObjectArray(array, value -> value / 2.0, Double.class); assertThat(output).containsExactly(multipliedExpectedArray); }

For primitive types, we'll have to box our values first.

As an alternative, we can turn to Java 8's Streams to carry out the mapping for us.

We'll need to transform the array into a Stream of Objects first. We can do so with the Arrays.stream method.

For example, if we want to map our int values to a custom String representation, we'll implement this:

String[] stringArray = Arrays.stream(array) .mapToObj(value -> String.format("Value: %s", value)) .toArray(String[]::new);

14. Filter Values in an Array

Filtering out values from a collection is a common task that we might have to perform in more than one occasion.

This is because at the time we create the array that will receive the values, we can't be sure of its final size. Therefore, we'll rely on the Streams approach again.

Imagine we want to remove all odd numbers from an array:

int[] evenArray = Arrays.stream(array) .filter(value -> value % 2 == 0) .toArray();

15. Other Common Array Operations

There are, of course, plenty of other array operations that we might need to perform.

Apart from the ones shown in this tutorial, we've extensively covered other operations in the dedicated posts:

  • Check if a Java Array Contains a Value
  • How to Copy an Array in Java
  • Removing the First Element of an Array
  • Finding the Min and Max in an Array with Java
  • Find Sum and Average in a Java Array
  • How to Invert an Array in Java
  • Gabung dan Pisahkan Array dan Koleksi di Java
  • Menggabungkan Berbagai Jenis Koleksi di Java
  • Temukan Semua Pasangan Angka dalam Array Yang Menjumlahkan Jumlah Yang Diberikan
  • Menyortir di Jawa
  • Kalkulator Frekuensi Kata yang Efisien di Java
  • Sortasi Penyisipan di Jawa

16. Kesimpulan

Array adalah salah satu fungsi inti Java, dan oleh karena itu sangat penting untuk memahami cara kerjanya dan untuk mengetahui apa yang bisa dan tidak bisa kita lakukan dengannya.

Dalam tutorial ini, kami mempelajari bagaimana kami dapat menangani operasi array dengan tepat dalam skenario umum.

Seperti biasa, kode sumber lengkap dari contoh yang berfungsi tersedia di repo Github kami.