Array di Java: Penjelasan – Contoh dan Kegunaannya

Apa itu Array ?

Array digunakan untuk menyimpan beberapa nilai dalam satu variabel, bukan mendeklarasikan variabel terpisah untuk setiap nilai. Untuk mendeklarasikan sebuah array, tentukan tipe variabel dengan tanda kurung siku. Biasanya, array adalah kumpulan elemen sejenis yang memiliki lokasi memori yang berdekatan.

Hampir sama dengan array di javascript, Array Java adalah objek yang berisi elemen tipe data serupa. Selain itu, elemen array disimpan di lokasi memori yang berdekatan.

Ini adalah struktur data tempat kami menyimpan elemen serupa. Kita hanya dapat menyimpan satu set elemen tetap dalam larik Java. Array di Java berbasis indeks, elemen pertama dari array disimpan di indeks ke-0, elemen ke-2 disimpan di indeks ke-1 dan seterusnya.

Tidak seperti C / C ++, kita bisa mendapatkan panjang array menggunakan anggota panjang. Di C / C ++, kita perlu menggunakan operator sizeof.

Di Java, array adalah objek dari kelas yang dibuat secara dinamis. Array Java mewarisi kelas Object, dan mengimplementasikan antarmuka Serializable serta Cloneable.

Kita bisa menyimpan nilai atau objek primitif dalam sebuah array di Java. Seperti C / C ++, kita juga dapat membuat array dimentional atau multidimentional di Java. Selain itu, Java menyediakan fitur array anonim yang tidak tersedia di C / C ++.

Java menyediakan struktur data, larik, yang menyimpan kumpulan elemen berurutan berukuran tetap dari tipe yang sama.

Sebuah array digunakan untuk menyimpan sekumpulan data, tetapi seringkali lebih berguna untuk menganggap array sebagai kumpulan variabel dengan tipe yang sama.

Alih-alih mendeklarasikan variabel individual, seperti bilangan0, bilangan1, …, dan bilangan99, Anda mendeklarasikan satu variabel larik seperti bilangan dan menggunakan bilangan [0], bilangan [1], dan …, bilangan [99] untuk mewakili variabel individu. Tutorial ini memperkenalkan cara mendeklarasikan variabel array, membuat array, dan memproses array menggunakan variabel yang diindeks

Deklarasi Array Pada Java

Untuk menggunakan array dalam program, Anda harus mendeklarasikan variabel untuk mereferensikan array, dan Anda harus menentukan jenis array yang dapat direferensikan oleh variabel. Berikut adalah sintaks untuk mendeklarasikan variabel array

dataType[] arrayRefVar;   // preferred way.
or
dataType arrayRefVar[];  // works but not preferred way.

// contoh lainnya adalah 

double[] myList;   // preferred way.
or
double myList[];   // works but not preferred way.

Catatan: style dataType [] arrayRefVar lebih disukai. Style dataType arrayRefVar [] berasal dari bahasa C / C ++ dan diadopsi di Java untuk mengakomodasi pemrogram C / C ++.

Membuat Array pada Java

Anda dapat membuat array dengan menggunakan operator baru dengan sintaks berikut

String[] cars;

Kami sekarang telah mendeklarasikan variabel yang menampung array string. Untuk memasukkan nilai ke dalamnya, kita dapat menggunakan literal array – tempatkan nilai dalam daftar yang dipisahkan koma, di dalam tanda kurung kurawal.

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

Untuk membuat array bilangan bulat, Anda bisa menulis seperti ini

int[] myNum = {10, 20, 30, 40};

Kemudian kita dapat membuat contoh sintaks lain dengan cara

arrayRefVar = new dataType[arraySize];

Pernyataan di atas melakukan dua hal yaitu

1. Ini membuat sebuah array menggunakan dataType [arraySize] baru.
2. Ini memberikan referensi dari array yang baru dibuat ke variabel arrayRefVar.

Mendeklarasikan variabel array, membuat array, dan menetapkan referensi array ke variabel dapat digabungkan dalam satu pernyataan, seperti yang ditunjukkan di bawah ini

dataType[] arrayRefVar = new dataType[arraySize];

Alternatifnya, Anda dapat membuat array sebagai berikut

dataType[] arrayRefVar = {value0, value1, ..., valuek};

Elemen array diakses melalui indeks. Indeks array berbasis 0; artinya, mereka mulai dari 0 hingga arrayRefVar.length-1. Pernyataan berikut mendeklarasikan variabel array, myList, membuat array 10 elemen tipe ganda dan memberikan referensinya ke myList

double[] myList = new double[10];

Gambar diatas mewakili array myList. Di sini, myList memiliki sepuluh nilai ganda dan indeksnya dari 0 hingga 9.

Keuntungan Menggunakan Array

1. Optimasi Kode yaitu Itu membuat kode dioptimalkan, kita dapat mengambil atau mengurutkan data secara efisien.
2. Random access yaitu kita bisa mendapatkan data apa pun yang terletak di posisi indeks.

Kerugian Menggunakan Array

1. Ukuran yang terbatas yaitu kita hanya dapat menyimpan ukuran tetap elemen dalam larik. Ukurannya tidak bertambah saat runtime. Untuk mengatasi masalah ini, framework kumpulan digunakan di Java yang tumbuh secara otomatis.

Deklarasi, Instansiasi dan Inisialisasi Array pada Java

Saat memproses elemen array, kita sering menggunakan for loop atau foreach loop karena semua elemen dalam array memiliki tipe yang sama dan ukuran array diketahui. Berikut adalah contoh lengkap yang menunjukkan cara membuat, menginisialisasi, dan memproses array

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
     
      // Summing all elements
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      
      // Finding the largest element
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);  
   }
}

Ini akan menghasilkan hasil sebagai berikut

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Contoh lain kita juga dapat mengakses elemen array dengan mengacu pada nomor indeks. Pernyataan ini mengakses nilai elemen pertama di mobil

String [] mobil = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println (mobil [0]);
// Mengeluarkan Volvo
// Catatan: Indeks array dimulai dengan 0: [0] adalah elemen pertama. [1] adalah elemen kedua dan seterusnya.

Kemudian Contoh lainnya bisa membuat seperti ini

class Testarray1{  
public static void main(String args[]){  
int a[]={33,3,4,5};//declaration, instantiation and initialization  
//printing array  
for(int i=0;i<a.length;i++)//length is the property of array  
System.out.println(a[i]);  
}}  // Maka akan menghasilkan output : 33, 3, 4, 5

Mengganti Element Array

Untuk mengubah nilai elemen tertentu, lihat nomor indeks contohnya dapat dilihat pada kode berikut

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
cars[0] = "Opel";
System.out.println(cars[0]);
// Now outputs Opel instead of Volvo

Array Length

Untuk mengetahui berapa banyak elemen yang dimiliki sebuah array, gunakan properti length, contohnya dapat digunakan seperti ini

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars.length);
// Outputs 4

Looping Array pada Java

Anda dapat melakukan loop melalui elemen array dengan for loop, dan menggunakan properti length untuk menentukan berapa kali loop harus dijalankan. Contoh berikut menampilkan semua elemen dalam array mobil

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (int i = 0; i < cars.length; i++) {
  System.out.println(cars[i]);
}

Looping ForEach

Ada juga loop “for-each”, yang digunakan secara eksklusif untuk melakukan loop melalui elemen dalam array. JDK 1.5 memperkenalkan loop for baru yang dikenal sebagai loop foreach atau loop for yang disempurnakan, yang memungkinkan Anda melintasi larik lengkap secara berurutan tanpa menggunakan variabel indeks. Kita dapat membuat looping dengan menggunakan sintaks berikut

for (type variable : arrayname) {
  ...
}

Contoh berikut mengeluarkan semua elemen dalam array mobil, menggunakan loop “for each”

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (String i : cars) {
  System.out.println(i);
}

Contoh di atas dapat dibaca seperti ini: untuk setiap elemen String (disebut i – seperti dalam indeks) di mobil, cetak nilai i. Jika Anda membandingkan loop for dan for-each, Anda akan melihat bahwa metode for-each lebih mudah ditulis, tidak memerlukan penghitung (menggunakan properti length), dan lebih mudah dibaca.

Contoh lainnya dari kode berikut menampilkan semua elemen dalam array myList

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

kemudian akan menghasilkan output

1.9
2.9
3.4
3.5

Contoh Lainnya bisa dengan membuat seperti ini

//Java Program to print the array elements using for-each loop  
class Testarray1{  
public static void main(String args[]){  
int arr[]={33,3,4,5};  
//printing array using for-each loop  
for(int i:arr)  
System.out.println(i);  
}
} // Maka akan menghasilkan output : 33, 3, 4, 5  

Passing Array ke Methods

Sama seperti Anda bisa meneruskan nilai tipe primitif ke metode, Anda juga bisa meneruskan array ke metode. Misalnya, metode berikut menampilkan elemen dalam array int

public static void printArray(int[] array) {
   for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
   }
}

Anda bisa memanggilnya dengan melewatkan sebuah array. Misalnya, pernyataan berikut memanggil metode printArray untuk menampilkan 3, 1, 2, 6, 4, dan 2

printArray(new int[]{3, 1, 2, 6, 4, 2});

Kita dapat melewatkan array java ke metode sehingga kita dapat menggunakan kembali logika yang sama pada array apa pun. Mari kita lihat contoh sederhana untuk mendapatkan jumlah minimum dari sebuah array menggunakan sebuah metode

//Java Program to demonstrate the way of passing an array  
//to method.  
class Testarray2{  
//creating a method which receives an array as a parameter  
static void min(int arr[]){  
int min=arr[0];  
for(int i=1;i<arr.length;i++)  
 if(min>arr[i])  
  min=arr[i];  
  
System.out.println(min);  
}  
  
public static void main(String args[]){  
int a[]={33,3,4,5};//declaring and initializing an array  
min(a);//passing array to method  
}
}  // Maka output yang dihasilkan adalah 3

Mengembalikan Sebuah Array Dari Methods

Suatu metode juga dapat mengembalikan array. Misalnya, metode berikut mengembalikan array yang merupakan pembalikan array lainnya

public static int[] reverse(int[] list) {
   int[] result = new int[list.length];

   for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
      result[j] = list[i];
   }
   return result;
}

Kita juga bisa mengembalikan array dari metode di Java dengan membuat kode berikut

//Java Program to return an array from the method  
class TestReturnArray{  
//creating method which returns an array  
static int[] get(){  
return new int[]{10,30,50,90,60};  
}  
  
public static void main(String args[]){  
//calling method which returns an array  
int arr[]=get();  
//printing the values of an array  
for(int i=0;i<arr.length;i++)  
System.out.println(arr[i]);  
}
}  

Maka kita dapat memperoleh hasil berikut

10
30
50
90
60

Anonymous Array in Java

Java mendukung fitur array anonim, jadi Anda tidak perlu mendeklarasikan array sambil meneruskan array ke metode. Contohnya dapat dilihat pada kode berikut

public class TestAnonymousArray{  
//creating a method which receives an array as a parameter  
static void printArray(int arr[]){  
for(int i=0;i<arr.length;i++)  
System.out.println(arr[i]);  
}  
  
public static void main(String args[]){  
printArray(new int[]{10,22,44,66});//passing anonymous array to method  
}
}  

Kemudian akan menghasilkan output

10
22
44
66

ArrayIndexOutOfBoundsException pada Java

Java Virtual Machine (JVM) menampilkan ArrayIndexOutOfBoundsException jika panjang array negatif, sama dengan ukuran array atau lebih besar dari ukuran array saat melintasi array. Contoh ini dapat dilihat pada kode berikut

//Java Program to demonstrate the case of   
//ArrayIndexOutOfBoundsException in a Java Array.  
public class TestArrayException{  
public static void main(String args[]){  
int arr[]={50,60,70,80};  
for(int i=0;i<=arr.length;i++){  
System.out.println(arr[i]);  
}  
}
}  

Selanjutnya kita dapat melihat hasil berikut

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
	at TestArrayException.main(TestArrayException.java:5)
50
60
70
80

Kelas Pada Array Java

Kelas java.util.Arrays berisi berbagai metode statis untuk mengurutkan dan mencari array, membandingkan array, dan mengisi elemen array. Metode ini kelebihan beban untuk semua tipe primitif.

• public static int binarySearch(Object[] a, Object key) yaitu Mencari array tertentu dari Object (Byte, Int, double, dan lainnya.) Untuk nilai yang ditentukan menggunakan algoritma pencarian biner. Larik harus diurutkan sebelum melakukan panggilan ini. Ini mengembalikan indeks dari kunci pencarian, jika itu terdapat dalam daftar; jika tidak, ia mengembalikan (- (titik penyisipan + 1)).
• public static boolean equals(long[] a, long[] a2) yaitu Mengembalikan nilai benar jika dua array panjang yang ditentukan sama satu sama lain. Dua array dianggap sama jika kedua array berisi jumlah elemen yang sama, dan semua pasangan elemen yang sesuai dalam dua array adalah sama. Ini mengembalikan nilai true jika dua larik sama. Metode yang sama dapat digunakan oleh semua tipe data primitif lainnya (Byte, short, Int, dan lainnya).
• public static void fill(int[] a, int val) yaitu menetapkan nilai int yang ditentukan ke setiap elemen dari array int yang ditentukan. Metode yang sama dapat digunakan oleh semua tipe data primitif lainnya (Byte, short, Int, dan lainnya).
• public static void sort(Object[] a) yaitu mengurutkan array objek yang ditentukan ke dalam urutan naik , sesuai dengan urutan alami elemennya. Metode yang sama dapat digunakan oleh semua tipe data primitif lainnya (Byte, short, Int, dan lainnya).

Tipe Array pada Java

Ada dua jenis tipe array pada Java yaitu

1. Array Dimensi Tunggal (Single Dimensional Array).
2. Array Multidimensi (MultiDimensional Array).

Single Dimensional Array

Sintaks untuk Menyatakan Array di Java yaitu

dataType[] arr; (or)  
dataType []arr; (or)  
dataType arr[]; 

Instansiasi array pada Java dapat dilakukan dengan

arrayRefVar=new datatype[size];  

Mari kita lihat contoh sederhana dari java array, dimana kita akan mendeklarasikan, membuat instance, menginisialisasi dan melintasi sebuah array. Contoh Programnya pada java ditunjukkan pada kode dibawah

class Testarray{  
public static void main(String args[]){  
int a[]=new int[5];//declaration and instantiation  
a[0]=10;//initialization  
a[1]=20;  
a[2]=70;  
a[3]=40;  
a[4]=50;  
//traversing array  
for(int i=0;i<a.length;i++)//length is the property of array  
System.out.println(a[i]);  
}
} // akan menghasilkan output : 
                                    //10
                                    //20
                                    //70
                                    //40
                                    //50

Multidimensional Array

Dalam kasus seperti ini, data disimpan dalam indeks berbasis baris dan kolom (juga dikenal sebagai bentuk matriks). Array multidimensi adalah Array yang berisi satu atau lebih Array. Untuk membuat larik dua dimensi, tambahkan setiap Array dalam kumpulan kurung kurawal miliknya sendiri. Sintaks yang dapat dibuat menggunakan multidimensional arry ini adalah

Sintaks untuk Mendeklarasi Array Multidimensi di Java

dataType[][] arrayRefVar; (or)  
dataType [][]arrayRefVar; (or)  
dataType arrayRefVar[][]; (or)  
dataType []arrayRefVar[];  

Sintaks untuk Instansiasi Array Multidimensi di Java

int[][] arr = new int[3][3];//3 row and 3 column  

Sintaks untuk Inisialisasi Array Multidimensi di Java

arr[0][0]=1;  
arr[0][1]=2;  
arr[0][2]=3;  
arr[1][0]=4;  
arr[1][1]=5;  
arr[1][2]=6;  
arr[2][0]=7;  
arr[2][1]=8;  
arr[2][2]=9; 

Contoh-contoh sederhana pada Multidimensional Array yaitu

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
int x = myNumbers[1][2];
System.out.println(x); // Outputs 7

myNumbers sekarang menjadi sebuah array dengan dua array sebagai elemennya. Untuk mengakses elemen dari array myNumbers, tentukan dua indeks: satu untuk array, dan satu lagi untuk elemen di dalam array itu. Contoh diatas adalah cara mengakses elemen ketiga (2) di array kedua (1) dari myNumbers. Kita juga dapat menggunakan perulangan for di dalam perulangan for lainnya untuk mendapatkan elemen dari array dua dimensi (kita masih harus menunjuk ke dua indeks)

public class MyClass {
  public static void main(String[] args) {
    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
    for (int i = 0; i < myNumbers.length; ++i) {
      for(int j = 0; j < myNumbers[i].length; ++j) {
        System.out.println(myNumbers[i][j]);
      }
    }
  }
}

Contoh lainnya adalah dapat dilihat pada kode berikut. Mari kita lihat contoh sederhana untuk mendeklarasikan, membuat instance, menginisialisasi, dan mencetak array 2 Dimensional.

class Testarray3{  
public static void main(String args[]){  
//declaring and initializing 2D array  
int arr[][]={{1,2,3},{2,4,5},{4,4,5}};  
//printing 2D array  
for(int i=0;i<3;i++){  
 for(int j=0;j<3;j++){  
   System.out.print(arr[i][j]+" ");  
 }  
 System.out.println();  
}  
}
}  

Yang akan menghasilkan output

1 2 3
2 4 5
4 4 5

Jagged Array pada Java

Jika kita membuat kolom ganjil dalam array 2D, ini dikenal sebagai array jagged. Dengan kata lain, ini adalah array – array dengan jumlah kolom berbeda. Kita bisa lihat dengan contoh kode berikut

//Java Program to illustrate the jagged array  
class TestJaggedArray{  
    public static void main(String[] args){  
        //declaring a 2D array with odd columns  
        int arr[][] = new int[3][];  
        arr[0] = new int[3];  
        arr[1] = new int[4];  
        arr[2] = new int[2];  
        //initializing a jagged array  
        int count = 0;  
        for (int i=0; i<arr.length; i++)  
            for(int j=0; j<arr[i].length; j++)  
                arr[i][j] = count++;  
   
        //printing the data of a jagged array   
        for (int i=0; i<arr.length; i++){  
            for (int j=0; j<arr[i].length; j++){  
                System.out.print(arr[i][j]+" ");  
            }  
            System.out.println();//new line  
        }  
    }  
} 

Outputnya akan menghasilkan : 
0 1 2 
3 4 5 6 
7 8 

Method getClass() dan getName()

Di Java, array adalah objek. Untuk objek array, dibuat kelas proxy yang namanya bisa diperoleh dengan metode getClass (). getName () pada objek tersebut. contoh penggunaanya adalah

//Java Program to get the class name of array in Java  
class Testarray4{  
public static void main(String args[]){  
//declaration and initialization of array  
int arr[]={4,4,5};  
//getting the class name of Java array  
Class c=arr.getClass();  
String name=c.getName();  
//printing the class name of Java array   
System.out.println(name);  
  
}
}  // akan menghasilkan output : I

Copy Array pada Java

Kita bisa menyalin array ke array lain dengan metode arraycopy () dari kelas Sistem. Sintaks untuk mengcopy array pada java adalah

public static void arraycopy(  
Object src, int srcPos,Object dest, int destPos, int length  
)

Agar lebih jelas maka kita akan membuat sebuah contohnya yaitu

class TestArrayCopyDemo {  
    public static void main(String[] args) {  
        //declaring a source array  
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',  
                'i', 'n', 'a', 't', 'e', 'd' };  
        //declaring a destination array  
        char[] copyTo = new char[7];  
        //copying array using System.arraycopy() method  
        System.arraycopy(copyFrom, 2, copyTo, 0, 7);  
        //printing the destination array  
        System.out.println(String.valueOf(copyTo));  
    }  
}  // output yang dihasilkan adalah caffein

Clonning Array pada Java

Karena, array Java mengimplementasikan antarmuka Cloneable, kita dapat membuat tiruan dari array Java. Jika kita membuat tiruan dari larik berdimensi tunggal, itu membuat salinan dalam larik Java. Artinya, ini akan menyalin nilai sebenarnya. Tapi, jika kita membuat klon dari array multidimensi, itu membuat salinan dangkal dari array Java yang berarti menyalin referensi. Contohnya dapat kita lihat pada kode berikut

//Java Program to clone the array  
class Testarray1{  
public static void main(String args[]){  
int arr[]={33,3,4,5};  
System.out.println("Printing original array:");  
for(int i:arr)  
System.out.println(i);  
  
System.out.println("Printing clone of the array:");  
int carr[]=arr.clone();  
for(int i:carr)  
System.out.println(i);  
  
System.out.println("Are both equal?");  
System.out.println(arr==carr);  
  
}
}  

Maka didapatkan output berikut

Printing original array:
33
3
4
5
Printing clone of the array:
33
3
4
5
Are both equal?
false

Penambahan 2 Matriks pada Java

Mari kita lihat contoh sederhana yang menambahkan dua matriks

class Testarray5{  
public static void main(String args[]){  
//creating two matrices  
int a[][]={{1,3,4},{3,4,5}};  
int b[][]={{1,3,4},{3,4,5}};  
  
//creating another matrix to store the sum of two matrices  
int c[][]=new int[2][3];  
  
//adding and printing addition of 2 matrices  
for(int i=0;i<2;i++){  
for(int j=0;j<3;j++){  
c[i][j]=a[i][j]+b[i][j];  
System.out.print(c[i][j]+" ");  
}  
System.out.println();//new line  
}  
  
}
}  

outputnya adalah

2 6 8
6 8 10

Perkalian 2 Matriks pada Java

Dalam kasus perkalian matriks, elemen satu baris dari matriks pertama dikalikan dengan semua kolom dari matriks kedua yang dapat dipahami dengan kode di bawah ini. Mari kita lihat contoh sederhana untuk mengalikan dua matriks dari 3 baris dan 3 kolom.

//Java Program to multiply two matrices  
public class MatrixMultiplicationExample{  
public static void main(String args[]){  
//creating two matrices    
int a[][]={{1,1,1},{2,2,2},{3,3,3}};    
int b[][]={{1,1,1},{2,2,2},{3,3,3}};    
    
//creating another matrix to store the multiplication of two matrices    
int c[][]=new int[3][3];  //3 rows and 3 columns  
    
//multiplying and printing multiplication of 2 matrices    
for(int i=0;i<3;i++){    
for(int j=0;j<3;j++){    
c[i][j]=0;      
for(int k=0;k<3;k++)      
{      
c[i][j]+=a[i][k]*b[k][j];      
}//end of k loop  
System.out.print(c[i][j]+" ");  //printing matrix element  
}//end of j loop  
System.out.println();//new line    
}    
}
}  

Output yang dihasilkan akan menjadi

6 6 6 
12 12 12 
18 18 18