Pengantar penggunaan array JAVA

Penulis：Eve Cole Waktu Pembaruan：2024-11-19 16:12:02

Ada tiga perbedaan utama antara array JAVA dan kelas kontainer: efisiensi, tipe, dan kemampuan menyimpan tipe dasar . Di JAVA, array adalah cara paling efisien untuk menyimpan dan mengakses urutan referensi objek secara acak. Array adalah urutan linier sederhana, yang membuat akses elemen menjadi sangat cepat. Namun harga yang harus dibayar untuk hal ini adalah ukuran arraynya tetap dan tidak dapat diubah selama masa pakainya.

Berkat mekanisme generik dan pengemasan otomatis, container kini dapat digunakan dengan tipe primitif semudah array. Baik array maupun container dapat mencegah Anda menyalahgunakannya sampai batas tertentu. Jika keduanya melampaui batas, Anda akan mendapatkan RuntimeException. Satu-satunya keuntungan yang tersisa dari array adalah efisiensi. Namun, jika Anda ingin menyelesaikan masalah yang lebih umum, array mungkin terlalu membatasi, jadi dalam hal ini kebanyakan orang akan tetap memilih container.

Oleh karena itu, jika Anda menggunakan versi JAVA terbaru, Anda sebaiknya memilih container daripada array. Program hanya boleh difaktorkan ulang menjadi array jika kinerja terbukti menjadi masalah dan peralihan ke array akan meningkatkan kinerja.

【inisialisasi】
JAVA memiliki peraturan yang sangat ketat mengenai inisialisasi array, yang secara efektif dapat mencegah penyalahgunaan array. Jika ada kesalahan inisialisasi, Anda akan mendapatkan CompileException alih-alih RuntimeException secara langsung. Tidak ada yang dapat dilakukan dengan referensi array ini sampai array diinisialisasi dengan benar.
Definisi array mencakup array int[] dan array int[]. Umumnya, gaya pertama digunakan untuk memisahkan tipe dari nama variabel.
Ada dua cara untuk menginisialisasi array, inisialisasi statis dan inisialisasi dinamis. Panjangnya harus ditentukan selama inisialisasi. Panjang dimensi pertama dari array multidimensi harus ditunjukkan, dan harus ditentukan dari dimensi tinggi ke rendah. Tindakan inisialisasi bisa berada di mana saja dalam kode, namun metode {} hanya bisa muncul di tempat array dibuat. Lihat program untuk metode inisialisasi spesifik:

Copy kode kodenya sebagai berikut:

kelas publik javaArrayInit{
public static void main(String args[]){
int[] arrayA; //tidak diinisialisasi
int[] arrayB = new int[5]; //inisialisasi statis
//Sistem.keluar.println(arrayA.length); //CompileException
System.out.println("arrayB length: " + arrayB.length); //Tidak dapat menyimpan jumlah elemen sebenarnya

arrayA = new int[10]; //Inisialisasi dinamis
System.out.println("panjang arrayA: " + arrayA.panjang);

int[] arrayC = int baru[]{1,2,3,4};
System.out.println("panjang arrayC: " + arrayC.panjang);

//int[] arrayD = new int[1]{1}; //inisialisasi, dimensi, dan nilai inisialisasi yang salah tidak dapat ditentukan secara bersamaan

int[][] arrayE = int baru[1][];
System.out.println("panjang arrayE: " + arrayE.panjang);

//int[][] arrayF = new int[][2]; //Panjang dimensi tinggi harus ditentukan terlebih dahulu

int[][] arrayG = int baru[][]{{1,2,3,4},{5,6,7},{7,24,23,24}};
System.out.println("panjang arrayG: " + arrayG.panjang);

int[][][] arrayH = int baru[][][]{{{1,2,3},{4,5,6},{7,8,9},{10,11,12} }};
System.out.println("panjang arrayH: " + arrayH.panjang);

dummyArray[] arrayI = {new dummyArray(),new dummyArray()}; //Jenis array khusus
System.out.println("panjang arrayI: " + arrayI.panjang);
System.out.println("arrayI[1]: " + arrayI[1].getValue());

dummyArray[] arrayK = dummyArray baru[5];
Sistem.keluar.println("arrayK[0]: " + arrayK[0]); //null
for(int i = 0; i < arrayK.panjang; i++){
arrayK[i] = dummyArray baru();
}
Sistem.keluar.println("arrayK[0]: " + arrayK[0].getValue()); //2
}
}
kelas dummyArray{
suhu int statis pribadi;
pribadi final int arrayValue = temp++;
publik int getValue(){
kembalikan nilai array;
}
}

Keluaran:

panjang arrayB: 5
panjang arrayA: 10
panjang arrayC: 4
panjang arrayE: 1
panjang arrayG: 3
panjang arrayH: 1
panjang arrayI: 2
susunanI[1]: 1
susunanK[0]: nol
susunanK[0]: 2

【panjang】
Panjang anggota read-only adalah bagian dari objek array (walaupun variabel ini sebenarnya tidak dideklarasikan di API dan dihasilkan secara dinamis saat runtime). Sintaks [] adalah satu-satunya cara untuk mengakses objek array, dan container diakses melalui metode get(). Anda dapat menggunakan Array.length untuk mendapatkan ukuran array. Perhatikan bahwa ini berbeda dari String.length() tipe String. Array menggunakan variabel anggota, sedangkan String menggunakan metode anggota. Pada saat yang sama, Array.length hanya bisa mendapatkan ukuran array, tapi tidak bisa mengetahui berapa banyak elemen sebenarnya yang dimiliki array. Panjang array multidimensi hanya menghitung panjang dimensi pertama.

Copy kode kodenya sebagai berikut:

kelas publik javaArrayLength{
public static void main(String args[]){
int[] arrayA = int baru[15];
larikA[1] = 1;
larikA[2] = 2;
larikA[3] = 3;
System.out.println("panjang arrayA: " + arrayA.panjang);

int[][] arrayB = int baru[10][];
System.out.println("panjang arrayB: " + arrayB.panjang);

int[][] arrayC = int baru[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,};//Perhatikan koma setelahnya
System.out.println("panjang arrayC: " + arrayC.panjang);

int[][] arrayD = int baru[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7} ,{}};
System.out.println("panjang arrayD: " + arrayD.panjang);
}
}
Keluaran:

panjang arrayA: 15
panjang arrayB: 10
panjang arrayC: 3
panjang arrayD: 4

【Array.isi】
Arrays.fill adalah metode yang sangat terbatas karena hanya dapat mengisi setiap posisi dengan nilai yang sama (atau, dalam kasus objek, menyalin referensi yang sama untuk diisi). Menggunakan Arrays.fill dapat mengisi seluruh array atau area tertentu dari array, tetapi karena Arrays.fill hanya dapat dipanggil dengan satu nilai, ini tidak terlalu berguna.

[Tugas dan Referensi]
Ketika array JAVA diinisialisasi, array tersebut hanya memiliki referensi ke array tersebut, dan tidak ada ruang penyimpanan yang dialokasikan ke array tersebut. Oleh karena itu, penyalinan antar array tidak bisa begitu saja menggunakan penugasan "=", karena objek yang dioperasikan sama. Prosedur berikut ini:

Copy kode kodenya sebagai berikut:

kelas publik javaArrayQuote{
public static void main(String args[]){
String tesA = "tesA";
String tesB = "tesB";
String[] arrayA = string baru[]{"arrayA"};
String[] arrayB = String baru[]{"arrayB"};
tesB = tesA;
testB = "perubahan testB";
System.out.println("Saya testA, tidak ada perubahan: " + testA);
larikB = larikA;
arrayB[0] = "arrayB telah berubah";
System.out.println("Saya arrayA, tidak ada perubahan: " + arrayA[0]);

}
}
Keluaran:

Saya testA, saya tidak berubah: testA
Saya arrayA, saya tidak berubah: arrayB telah berubah

Terlihat bahwa ketika kita mengubah nilai arrayB[0], kita mengubah array yang direferensikan, sehingga kita mengeluarkan arrayA[0], yang sebenarnya sama dengan arrayB[0].

[Salinan susunan]
Cara menyalin array di JAVA:

1. Gunakan loop FOR untuk menyalin semua atau elemen tertentu, yang kurang efisien.
2. Gunakan metode clone untuk mendapatkan nilai array dan bukan referensi. Namun, clone tidak dapat menyalin elemen tertentu dan memiliki fleksibilitas yang rendah.
3. Gunakan metode System.arraycopy(src, srcPos, dest, destPos, length). Pustaka kelas standar Java menyediakan metode statis System.arraycopy(). Menggunakannya untuk menyalin array jauh lebih cepat daripada sistem loop for .arraycopy() adalah untuk Semua tipe kelebihan beban. Baik array tipe dasar maupun array objek dapat disalin menggunakan System.arraycopy(), tetapi array objek hanya menyalin referensi, dan tidak akan ada dua salinan objek. Ini disebut salinan dangkal.
src: larik sumber;
srcPos: posisi awal array sumber yang akan disalin;
tujuan: susunan tujuan;
destPos: posisi awal dimana array tujuan ditempatkan;
length: Panjang salinan.
Catatan: System.arraycopy() tidak melakukan pengemasan otomatis dan pembongkaran otomatis, sehingga kedua array harus bertipe sama atau dapat dikonversi ke array bertipe sama. Pada saat yang sama, metode ini juga dapat digunakan untuk menyalin array itu sendiri.
int[] tes ={0,1,2,3,4,5,6};
System.arraycopy(uji,0,uji,3,3);
Hasilnya adalah: {0,1,2,0,1,2,6};
Prosedur pengujiannya adalah sebagai berikut:

Copy kode kodenya sebagai berikut:

javaArrayCopy kelas publik{
public static void main(String args[]){
int[] larik = {1,2,3,4,5,6,7,8,9};
//untuk metode perulangan
int[] arrayA = int baru[9];
for(int i = 0; i < arrayA.panjang; i++){
larikA[i] = larik[i];
Sistem.keluar.cetak(arrayA[i] + ",");
}
//tes
Sistem.keluar.println("");
larikA[1] = 19;
for(int i = 0; i < arrayA.panjang; i++){
Sistem.keluar.cetak(arrayA[i] + ",");
}
Sistem.keluar.println("");
for(int i = 0; i < array.panjang; i++){
Sistem.keluar.cetak(array[i] + ",");
}
Sistem.keluar.println("");

//metode kloning
int[] arrayB = int baru[9];
arrayB = array.klon();
//tes
larikB[1] = 19;
for(int i = 0; i < arrayB.panjang; i++){
Sistem.keluar.cetak(arrayB[i] + ",");
}
Sistem.keluar.println("");
for(int i = 0; i < array.panjang; i++){
Sistem.keluar.cetak(array[i] + ",");
}
Sistem.keluar.println("");

//Metode System.arrayCopy
int[] arrayC = int baru[9];
System.arraycopy(array, 0, arrayC, 0, arrayC.length);
//tes
larikC[1] = 19;
for(int i = 0; i < arrayC.panjang; i++){
Sistem.keluar.cetak(arrayC[i] + ",");
}
Sistem.keluar.println("");
for(int i = 0; i < array.panjang; i++){
Sistem.keluar.cetak(array[i] + ",");
}
}
}

[Perbandingan susunan]
Array menyediakan metode sama dengan() yang kelebihan beban, yang kelebihan beban untuk semua tipe dan tipe Objek untuk membandingkan keseluruhan array. Syarat persamaan array adalah jumlah elemen harus sama, dan elemen pada posisi yang bersesuaian juga harus sama. Metode deepEquals() digunakan untuk perbandingan array multidimensi. Kedua array yang dibandingkan dengan metode Array.equals() harus berupa array dengan tipe yang sama.

Copy kode kodenya sebagai berikut:

import java.util.Array;
kelas publik javaArrayEquals{
public static void main(String args[]){
int[] larikA = {1,2,3};
int[] larikB = {1,2,3,};
int[] arrayC = int baru[4]; //jika int[] arrayC = int baru[3], hasilnya benar
larikC[0] = 1;
larikC[1] = 2;
larikC[2] = 3;
System.out.println(Arrays.equals(arrayA, arrayB));
System.out.println(Arrays.equals(arrayA, arrayC));

String[][] arrayD = {{"a","b"},{"c","d"}};
String[][] arrayE = {{"a","b"},{"c","d"}};
Sistem.keluar.println(Arrays.deepEquals(arrayD, arrayE));
}
}

[Penyortiran dan pencarian array]
Array menyediakan metode pengurutan bawaan sort(), yang dapat mengurutkan array tipe dasar atau array objek apa pun (objek harus mengimplementasikan antarmuka Comparable atau memiliki Comparator terkait). JAVA menyediakan metode pengurutan yang berbeda untuk tipe yang berbeda - pengurutan cepat yang dirancang untuk tipe dasar, dan "pengurutan gabungan stabil" yang dirancang untuk objek, jadi tidak perlu khawatir tentang efisiensi penyortiran array.
binerSearch() digunakan untuk menemukan elemen dalam larik yang diurutkan dengan cepat. Jika binerSearch() digunakan pada larik yang tidak diurutkan, hasil yang tidak terduga akan terjadi.

[array kembali]
C dan C++ tidak dapat mengembalikan sebuah array, hanya sebuah pointer ke array, karena mengembalikan sebuah array membuat sulit untuk mengontrol siklus hidup array dan dapat dengan mudah menyebabkan kebocoran memori. Java memungkinkan pengembalian array secara langsung, dan dapat didaur ulang melalui mekanisme pengumpulan sampah.

[Konversi Array dan Kontainer] [Tidak dapat mengonversi array tipe dasar]

Konversi array ke Daftar:

Copy kode kodenya sebagai berikut:

import java.util.*;
arrayToList kelas publik{
public static void main(String args[]){
String[] arrayA = {"a","b","c"};
Daftar listA = java.util.Arrays.asList(arrayA);
System.out.println("daftarA: " + daftarA);

int[] larikB = {1,2,3};
Daftar listB = java.util.Arrays.asList(arrayB);
System.out.println("daftarB: "+daftarB);

Bilangan bulat[] larikC = {1,2,3};
Daftar listC = java.util.Arrays.asList(arrayC);
System.out.println("daftarC: " + daftarC);
}
}
Keluaran:

daftarA: [a, b, c]
daftarB: [[I@de6ced]
daftarC: [1, 2, 3]

Mengapa keluaran int dan Integer berbeda?

Ubah Daftar menjadi Array

Copy kode kodenya sebagai berikut:

import java.util.*;
kelas publik listToArray{
public static void main(String args[]){
Daftar<String> daftar = Daftar Array baru<String>();
String[] susunan;
daftar.tambahkan("tesA");
daftar.tambahkan("tesB");
daftar.tambahkan("testC");
System.out.println("daftar: " + daftar);

String[] string = String baru[daftar.ukuran()];
array = daftar.toArray(string);
for(int i = 0, j = array.panjang; i < j; i++){
Sistem.keluar.cetak(array[i] + ",");
}
}
}
Outputnya adalah:

daftar: [tesA, tesB, tesC]
tesA,tesB,tesC

【Hapus data duplikat】
Konversi array dan kontainer dapat dengan mudah menghapus data duplikat dari array, tetapi jika array terlalu besar, efisiensi menjadi masalah.

Copy kode kodenya sebagai berikut:

import java.util.*;
kelas publik javaArrayUnik{
public static void main(String args[]){
String[] larik = {"a","b","a","a","c","b"};
arrayUnik(array);
//tes
for(int i = 0, j = arrayUnik(array).panjang; i < j; i++){
Sistem.keluar.cetak(arrayUnik(array)[i] + ",");
}
}

String statis publik[] arrayUnik(String[] array){
Daftar<String> daftar = Daftar Array baru<String>();
for(int i = 0, j = array.panjang; i < j; i++){
if(!list.contains(array[i])){
daftar.tambahkan(array[i]);
}
}
String[] string = String baru[daftar.ukuran()];
String[] arrayUnik = list.toArray(string);
kembalikan arrayUnik;
}
}

Mengenai masalah efisiensi, saya membuat perbandingan. Menjalankan array yang berisi 100.000 data di komputer saya membutuhkan waktu sekitar 577 ms, sedangkan menjalankan array yang berisi satu juta data membutuhkan waktu sekitar 5663 ms. Hal ini juga terkait dengan kemampuan pengoperasian komputer, namun jelas meningkat seiring dengan ukuran array.

Copy kode kodenya sebagai berikut:

import java.util.*;
kelas publik javaArrayUnik{
public static void main(String args[]){
Ganda[] array = baru Ganda[100000];
for(int i = 0, j = array.panjang; i < j; i++){
array[i] = Matematika.ceil(Matematika.acak()*1000);
}

Ganda[] arrayB = baru Ganda[1000000];
for(int i = 0, j = arrayB.panjang; i < j; i++){
arrayB[i] = Matematika.ceil(Matematika.acak()*1000);
}

System.out.println("mulai");
startTime panjang = Sistem.currentTimeMillis();
arrayUnik(array);
long endTime = Sistem.currentTimeMillis();
System.out.println("array waktu berjalan unik: " +(endTime - startTime) +"ms");

startTimeB panjang = Sistem.currentTimeMillis();
arrayUnik(arrayB);
long endTimeB = Sistem.currentTimeMillis();
System.out.println("waktu berjalan unik arrayB: " +(endTimeB - startTimeB) +"ms");
}

public static Double[] arrayUnik(Double[] array){
Daftar<Double> daftar = Daftar Array baru<Double>();
for(int i = 0, j = array.panjang; i < j; i++){
if(!list.contains(array[i])){
daftar.tambahkan(array[i]);
}
}
Ganda[] ganda = ganda baru[daftar.ukuran()];
Ganda[] arrayUnik = list.toArray(ganda);
kembalikan arrayUnik;
}
}
Keluaran:

awal
waktu proses unik array: 577ms
waktu proses unik arrayB: 5663ms