Array di Java: Penjelasan – Contoh dan Kegunaannya

Apa miliknya sendiri Array ?

Array digunakan untuk hemat sejumlah bernilai sangat satu berubah-ubah, agak mendeklarasikan berubah-ubah berbeda untuk setiap bernilai. Untuk mendeklarasikan sebuah array, membangun tipe berubah-ubah bersama indikasi kurung bersama. Biasanya, array adalah kumpulan komponen sejenis yang {memiliki} tempat pikiran yang berdekatan.

Hampir setiap bit sebagai bersama array di javascript, Array Java adalah sesuatu yang berisi komponen tipe informasi serupa. Selain miliknya sendiri, komponen array disimpan di tempat pikiran yang berdekatan.

Ini adalah rancangan informasi daerah tim kami hemat komponen serupa. Kita eksklusif dapat hemat satu set komponen dikoreksi sangat larik Java. Array di Java berbasis menandai, komponen memulai dengan berasal dari array disimpan di menandai ke dalam-0, komponen ke dalam-2 disimpan di menandai ke dalam-1 dan seterusnya.

Tidak seperti C / C ++, kita bisa dengan mudah mendapatkan durasi array menggunakan peserta durasi. Di C / C ++, kita penting menggunakan sopir sizeof.

Di Java, array adalah sesuatu berasal dari kursus yang dibuat secara menarik. Array Java dapatkan kursus Object, dan mengimplementasikan antarmuka Serializable serta Cloneable.

Kita bisa dengan mudah hemat bernilai atau bahkan sesuatu primitif sangat sebuah array di Java. Seperti C / C ++, kita tambahan dapat membuat array dimentional atau bahkan multidimentional di Java. Selain miliknya sendiri, Java berikan fungsi array dirahasiakan yang tidak dapat diakses di C / C ++.

Java berikan rancangan informasi, larik, yang hemat kumpulan komponen berurutan berukuran dikoreksi berasal dari tipe yang setiap bit sebagai.

Sebuah array digunakan untuk hemat sekumpulan informasi, tetapi seringkali lebih berharga untuk menganggap array sebagai kumpulan berubah-ubah bersama tipe yang setiap bit sebagai.

Alih-alih mendeklarasikan berubah-ubah particular person, seperti bilangan0, bilangan1, …, dan bilangan99, Anda mendeklarasikan satu berubah-ubah larik seperti bilangan dan menggunakan bilangan [0], bilangan [1], dan …, bilangan [99] untuk contoh berubah-ubah orang. Tutorial ini memperkenalkan metode mendeklarasikan berubah-ubah array, membuat array, dan memproses array menggunakan berubah-ubah yang diindeks

Deklarasi Array Pada Java

Untuk menggunakan array sangat rencana, Anda perlu mendeklarasikan berubah-ubah untuk mereferensikan array, dan Anda perlu menentukan jenis array yang dapat direferensikan melalui berubah-ubah. Berikut adalah sintaks untuk mendeklarasikan berubah-ubah array

dataType[] arrayRefVar;   // most well-liked manner.
or
dataType arrayRefVar[];  // works however not most well-liked manner.

// {contoh} berbagai lainnya adalah 

double[] myList;   // most well-liked manner.
or
double myList[];   // works however not most well-liked manner.

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

Membuat Array pada Java

Anda dapat membuat array bersama menggunakan sopir baru-baru ini bersama sintaks berikut

String[] automobiles;

Kami saat ini telah mendeklarasikan berubah-ubah yang menampung array tali. Untuk memasukkan bernilai ke dalam dalamnya, kita dapat menggunakan literal array – tempatkan bernilai sangat ikut yang dipisahkan koma, di sangat indikasi kurung kurawal.

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

Untuk membuat array bilangan bola, Anda bisa dengan mudah menulis seperti ini

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

Kemudian kita dapat membuat {contoh} sintaks satu lagi bersama metode

arrayRefVar = new dataType[arraySize];

Pernyataan di terbaik mengadakan sepasang titik yaitu

  1. Ini membuat sebuah array menggunakan dataType [arraySize] baru-baru ini.
  2. Ini memberikan dukungan berasal dari array yang baru-baru ini dibuat ke dalam berubah-ubah arrayRefVar.

Mendeklarasikan berubah-ubah array, membuat array, dan menetapkan dukungan array ke dalam berubah-ubah dapat digabungkan sangat satu klaim, seperti yang ditunjukkan di mendasarkan ini

dataType[] arrayRefVar = new dataType[arraySize];

Alternatifnya, Anda dapat membuat array sebagai berikut

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

Elemen array diakses dengan menandai. Indeks array berbasis 0; artinya, mereka semua awal berasal dari 0 hingga arrayRefVar.size-1. Pernyataan berikut mendeklarasikan berubah-ubah array, myList, membuat array 10 komponen tipe ganda dan memberikan referensinya ke dalam myList

double[] myList = new double[10];

Gambar diatas contoh array myList. Di sini, myList {memiliki} 10 bernilai ganda dan indeksnya berasal dari 0 hingga 9.

Keuntungan Menggunakan Array

  1. Optimasi Kode yaitu Itu membuat kode dioptimalkan, kita dapat mengambil atau bahkan mengurutkan informasi secara efektif.
  2. Random entry yaitu kita bisa dengan mudah mendapatkan informasi apa pun yang terletak di sikap menandai.

Kerugian Menggunakan Array

  1. Ukuran yang dibatasi yaitu kita eksklusif dapat hemat pengukuran dikoreksi komponen sangat larik. Ukurannya tidak bertambah menit runtime. Untuk ditaklukkan komplikasi ini, framework kumpulan digunakan di Java yang memperluas secara mobil.

Deklarasi, Instansiasi dan Inisialisasi Array pada Java

Saat memproses komponen array, kita umum menggunakan for loop atau bahkan foreach loop karena semua komponen sangat array {memiliki} tipe yang setiap bit sebagai dan pengukuran array diketahui. Berikut adalah {contoh} luas yang menunjukkan metode membuat, menginisialisasi, dan memproses array

public class CheckArray {

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

      // Print all of the array components
      for (int i = 0; i < myList.size; i++) {
         System.out.println(myList[i] + " ");
      }
     
      // Summing all components
      double jumlah total = 0;
      for (int i = 0; i < myList.size; i++) {
         jumlah total += myList[i];
      }
      System.out.println("Total is " + jumlah total);
      
      // Finding the most important component
      double max = myList[0];
      for (int i = 1; i < myList.size; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);  
   }
}

Ini pasti akan buat hasil akhir sebagai berikut

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Contoh satu lagi kita tambahan dapat mengakses komponen array bersama mengacu pada berbagai menandai. Pernyataan ini mengakses bernilai komponen memulai dengan di kendaraan

String [] kendaraan = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println (kendaraan [0]);
// Mengeluarkan Volvo
// Catatan: Indeks array dimulai bersama 0: [0] adalah komponen memulai dengan. [1] adalah komponen ke-2 dan seterusnya.

Kemudian Contoh berbagai lainnya bisa dengan mudah membuat seperti ini

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

Mengganti Element Array

Untuk ubah bernilai komponen tertentu, pemandangan berbagai menandai contohnya dapat dilihat pada kode berikut

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

Array Length

Untuk mengetahui berapa berbagai komponen yang dimiliki sebuah array, penggunaan bangunan size, contohnya dapat digunakan seperti ini

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

Anda dapat mengadakan loop dengan komponen array bersama for loop, dan menggunakan bangunan size untuk menentukan berapa kali loop perlu dijalankan. Contoh berikut menampilkan semua komponen sangat array kendaraan

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

Looping ForEach

Ada tambahan loop “for-every”, yang digunakan secara hanya untuk mengadakan loop dengan komponen sangat array. JDK 1.5 memperkenalkan loop for baru-baru ini yang mengerti sebagai loop foreach atau bahkan loop for yang disempurnakan, yang memungkinkan Anda melintasi larik luas secara berurutan tanpa menggunakan berubah-ubah menandai. Kita dapat membuat looping bersama menggunakan sintaks berikut

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

Contoh berikut mengeluarkan semua komponen sangat array kendaraan, menggunakan loop “for every”

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

Contoh di terbaik dapat dibaca seperti ini: untuk setiap komponen String (seharusnya i – seperti sangat menandai) di kendaraan, pencetakan bernilai i. Jika Anda membandingkan loop for dan for-every, Anda pasti akan hal bahwa prosedur for-every lebih nyaman ditulis, tidak memerlukan sebaliknya (menggunakan bangunan size), dan lebih nyaman dibaca.

Lihat lebih banyak:  Segala Hal tentang Kursor Laptop Tidak Bergerak (Penyebab dan Cara Mengatasinya)

Contoh berbagai lainnya berasal dari kode berikut menampilkan semua komponen sangat array myList

public class CheckArray {

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

      // Print all of the array components
      for (double component: myList) {
         System.out.println(component);
      }
   }
}

kemudian pasti akan buat output

1.9
2.9
3.4
3.5

Contoh Lainnya bisa dengan mudah bersama membuat seperti ini

//Java Program to print the array components utilizing for-every loop  
class Testarray1{  
public static void essential(String args[]){  
int arr[]={33,3,4,5};  
//printing array utilizing for-every loop  
for(int i:arr)  
System.out.println(i);  
}
} // Maka pasti akan buat output : 33, 3, 4, 5  

Passing Array ke dalam Methods

Sama seperti Anda bisa dengan mudah meneruskan bernilai tipe primitif ke dalam prosedur, Anda tambahan bisa dengan mudah meneruskan array ke dalam prosedur. Misalnya, prosedur berikut menampilkan komponen sangat array int

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

Anda bisa dengan mudah memanggilnya bersama melewatkan sebuah array. Misalnya, klaim berikut memanggil prosedur 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 dalam prosedur sehingga kita dapat menggunakan menghasilkan pemikiran yang setiap bit sebagai pada array apa pun. Mari kita pemandangan {contoh} masuk akal untuk mendapatkan kuantitas minimal berasal dari sebuah array menggunakan sebuah prosedur

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

Mengembalikan Sebuah Array Dari Methods

Suatu prosedur tambahan dapat mengembalikan array. Misalnya, prosedur berikut mengembalikan array yang merupakan pembalikan array berbagai lainnya

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

   for (int i = 0, j = outcome.size - 1; i < checklist.size; i++, j--) {
      outcome[j] = checklist[i];
   }
   return outcome;
}

Kita tambahan bisa dengan mudah mengembalikan array berasal dari prosedur di Java bersama membuat kode berikut

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

Maka kita dapat memperoleh hasil akhir berikut

10
30
50
90
60

Anonymous Array in Java

Java kembali fungsi array dirahasiakan, maka Anda tidak penting mendeklarasikan array sambil meneruskan array ke dalam prosedur. Contohnya dapat dilihat pada kode berikut

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

Kemudian pasti akan buat output

10
22
44
66

ArrayIndexOutOfBoundsException pada Java

Java Virtual Machine (JVM) menampilkan ArrayIndexOutOfBoundsException jika durasi array tidak menguntungkan, setiap bit sebagai bersama pengukuran array atau bahkan lebih substansial berasal dari pengukuran array menit melintasi array. Contoh ini dapat dilihat pada kode berikut

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

Selanjutnya kita dapat hal hasil akhir berikut

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

Kelas Pada Array Java

Kelas java.util.Arrays berisi banyak prosedur statis untuk mengurutkan dan mencari array, membandingkan array, dan mengisi komponen array. Metode ini kelebihan masalah untuk semua tipe primitif.

  • public static int binarySearch(Object[] a, Object key) yaitu Mencari array tertentu berasal dari Object (Byte, Int, double, dan berbagai lainnya.) Untuk bernilai yang ditentukan menggunakan algoritma perjalanan biner. Larik perlu diurutkan sebelumnya mengadakan panggilan telepon ini. Ini mengembalikan menandai berasal dari rahasia perjalanan, jika miliknya sendiri terdapat sangat ikut; jika tidak, ia mengembalikan (- (kerangka waktu penyisipan + 1)).
  • public static boolean equals(lengthy[] a, lengthy[] a2) yaitu Mengembalikan bernilai cara yang benar jika sepasang array durasi yang ditentukan setiap bit sebagai satu setiap bit sebagai satu lagi. Dua array dianggap setiap bit sebagai jika ke-2 array berisi kuantitas komponen yang setiap bit sebagai, dan semua suami atau istri komponen yang ideal sangat sepasang array adalah setiap bit sebagai. Ini mengembalikan bernilai true jika sepasang larik setiap bit sebagai. Metode yang setiap bit sebagai dapat digunakan melalui semua tipe informasi primitif berbagai lainnya (Byte, quick, Int, dan berbagai lainnya).
  • public static void fill(int[] a, int val) yaitu menetapkan bernilai int yang ditentukan ke dalam setiap komponen berasal dari array int yang ditentukan. Metode yang setiap bit sebagai dapat digunakan melalui semua tipe informasi primitif berbagai lainnya (Byte, quick, Int, dan berbagai lainnya).
  • public static void type(Object[] a) yaitu mengurutkan array sesuatu yang ditentukan ke dalam sangat seri perjalanan , ideal bersama seri organik elemennya. Metode yang setiap bit sebagai dapat digunakan melalui semua tipe informasi primitif berbagai lainnya (Byte, quick, Int, dan berbagai lainnya).
Lihat lebih banyak:  Perbedaan Machine Learning dan Deep Learning

Tipe Array pada Java

Ada sepasang 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 bersama

arrayRefVar=new datatype[size];  

Mari kita pemandangan {contoh} masuk akal berasal dari java array, dimana kita pasti akan mendeklarasikan, membuat occasion, menginisialisasi dan melintasi sebuah array. Contoh Programnya pada java ditunjukkan pada kode dibawah

class Testarray{  
public static void essential(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.size;i++)//size is the property of array  
System.out.println(a[i]);  
}
} // pasti akan buat output : 
                                    //10
                                    //20
                                    //70
                                    //40
                                    //50

Multidimensional Array

Dalam skenario seperti ini, informasi disimpan sangat menandai berbasis garis dan pilar (tambahan mengerti sebagai rancangan matriks). Array multidimensi adalah Array yang berisi satu atau bahkan lebih Array. Untuk membuat larik sepasang ukuran, menggabungkan setiap Array sangat kumpulan kurung kurawal miliknya dengan dirinya 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 three 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 masuk akal 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 saat ini jadilah sebuah array bersama sepasang array sebagai elemennya. Untuk mengakses komponen berasal dari array myNumbers, membangun sepasang menandai: satu untuk array, dan satu ekstra untuk komponen di sangat array miliknya sendiri. Contoh diatas adalah metode mengakses komponen 3 (2) di array ke-2 (1) berasal dari myNumbers. Kita tambahan dapat menggunakan perulangan for di sangat perulangan for berbagai lainnya untuk mendapatkan komponen berasal dari array sepasang ukuran (kita masih perlu menunjuk ke dalam sepasang menandai)

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

Contoh berbagai lainnya adalah dapat dilihat pada kode berikut. Mari kita pemandangan {contoh} masuk akal untuk mendeklarasikan, membuat occasion, menginisialisasi, dan mencetak array 2 Dimensional.

class Testarray3{  
public static void essential(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 pasti akan buat output

1 2 3
2 4 5
4 4 5

Jagged Array pada Java

Jika kita membuat pilar ganjil sangat array 2D, ini mengerti sebagai array jagged. Dengan frase satu lagi, ini adalah array – array bersama kuantitas pilar dengan cara yang berbeda. Kita bisa dengan mudah pemandangan bersama {contoh} kode berikut

//Java Program for example the jagged array  
class CheckJaggedArray{  
    public static void essential(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 depend = 0;  
        for (int i=0; i<arr.size; i++)  
            for(int j=0; j<arr[i].size; j++)  
                arr[i][j] = depend++;  
   
        //printing the informasi of a jagged array   
        for (int i=0; i<arr.size; i++){  
            for (int j=0; j<arr[i].size; j++){  
                System.out.print(arr[i][j]+" ");  
            }  
            System.out.println();//new line  
        }  
    }  
} 
Outputnya pasti akan buat : 
0 1 2 
3 4 5 6 
7 8 

Di Java, array adalah sesuatu. Untuk sesuatu array, dibuat kursus proxy yang namanya bisa dengan mudah diperoleh bersama prosedur getClass (). getName () pada sesuatu tersebut. {contoh} penggunaanya adalah

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

Copy Array pada Java

Kita bisa dengan mudah menyalin array ke dalam array satu lagi bersama prosedur arraycopy () berasal dari kursus Sistem. Sintaks untuk mengcopy array pada java adalah

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

Agar lebih pastinya jadi kita pasti akan membuat sebuah contohnya yaitu

class CheckArrayCopyDemo {  
    public static void essential(String[] args) {  
        //declaring a supply array  
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',  
                'i', 'n', 'a', 't', 'e', 'd' };  
        //declaring a vacation spot array  
        char[] copyTo = new char[7];  
        //copying array utilizing System.arraycopy() technique  
        System.arraycopy(copyFrom, 2, copyTo, 0, 7);  
        //printing the vacation spot 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 berasal dari array Java. Jika kita membuat tiruan berasal dari larik berdimensi eksklusif, miliknya sendiri membuat salinan sangat larik Java. Artinya, ini pasti akan menyalin bernilai faktanya. Tapi, jika kita membuat klon berasal dari array multidimensi, miliknya sendiri membuat salinan {dangkal} berasal dari array Java yang metode (PL) menyalin dukungan. Contohnya dapat kita pemandangan pada kode berikut

//Java Program to clone the array  
class Testarray1{  
public static void essential(String args[]){  
int arr[]={33,3,4,5};  
System.out.println("Printing unique 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 each equal?");  
System.out.println(arr==carr);  
  
}
}  

Maka didapatkan output berikut

Printing unique array:
33
3
4
5
Printing clone of the array:
33
3
4
5
Are each equal?
false

Penambahan 2 Matriks pada Java

Mari kita pemandangan {contoh} masuk akal yang menambahkan sepasang matriks

class Testarray5{  
public static void essential(String args[]){  
//creating two matrices  
int a[][]={{1,3,4},{3,4,5}};  
int b[][]={{1,3,4},{3,4,5}};  
  
//creating one other matrix to retailer the sum of two matrices  
int c[][]=new int[2][3];  
  
//including and printing addition of two 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 skenario perkalian matriks, komponen satu garis berasal dari matriks memulai dengan dikalikan bersama semua pilar berasal dari matriks ke-2 yang dapat dipahami bersama kode di mendasarkan ini. Mari kita pemandangan {contoh} masuk akal untuk mengalikan sepasang matriks berasal dari 3 garis dan 3 pilar.

//Java Program to multiply two matrices  
public class MatrixMultiplicationExample{  
public static void essential(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 one other matrix to retailer the multiplication of two matrices    
int c[][]=new int[3][3];  //3 rows and three columns  
    
//multiplying and printing multiplication of two matrices    
for(int i=0;i<3;i++){    
for(int j=0;j<3;j++){    
c[i][j]=0;      
for(int ok=0;ok<3;ok++)      
{      
c[i][j]+=a[i][k]*b[k][j];      
}//finish of ok loop  
System.out.print(c[i][j]+" ");  //printing matrix component  
}//finish of j loop  
System.out.println();//new line    
}    
}
}  

Output yang dihasilkan pasti akan jadilah

6 6 6 
12 12 12 
18 18 18 

Anda ringan menonton: Array di Java: Penjelasan – Contoh dan Kegunaannya

Lihat lebih banyak:  8 Cara Mengecek Laptop Rusak atau Tidak Wajib Diketahui

Sumber: https://taylorswift10years.com

Kategori: Teknologi

Leave a Reply