Tatasusunan — kelas pembantu

1. Arrayskelas

Seperti yang kita nyatakan sebelum ini, tatasusunan adalah sangat berguna dan kerap digunakan dalam pengaturcaraan.

Pencipta Java dengan cepat menyedari bahawa pengaturcara Java sering menulis kod yang sama apabila bekerja dengan tatasusunan. Contohnya, salin sebahagian tatasusunan ke tatasusunan lain, kod untuk mengisi setiap sel tatasusunan dengan nilai yang sama, paparkan kandungan tatasusunan dalam format yang mudah, dsb.

Itulah sebabnya mereka mencipta Arrayskelas khas (nama penuhnya ialah java.util.Arrays), meletakkan tindakan berkaitan tatasusunan yang paling popular ke dalamnya.

Ia mempunyai banyak kaedah untuk setiap kesempatan, tetapi mula-mula kita akan mempertimbangkan hanya 10 daripadanya — yang paling mudah dan paling kerap digunakan.

2.Arrays.toString()

Kaedah pertama yang akan kita lihat dipanggil Arrays.toString(). Tetapi pertama, sedikit latar belakang.

Setiap tatasusunan dalam Java mempunyai toString()kaedah, yang mengembalikan 'perwakilan teks tatasusunan'. Anda boleh mendapatkan perwakilan teks tatasusunan menggunakan pernyataan berikut:

String str = name.toString();

Di manakah namenama pembolehubah tatasusunan, dan strnama pembolehubah yang akan menyimpan perwakilan rentetan tatasusunan.

Tetapi jika anda cuba mencetak tatasusunan ke skrin menggunakan kaedah, kemungkinan besar anda akan melihat sesuatu seperti ini:System.out.println(name)

I@37afeb11

Huruf pertama Ibermaksud bahawa ia adalah inttatasusunan, dan simbol selepasnya @ialah alamat tatasusunan dalam ingatan. Di satu pihak, ini adalah maklumat yang disimpan dalam pembolehubah tatasusunan, tetapi di sisi lain, kami menjangkakan sesuatu yang berbeza, bukan?

Kami mahu melihat nilai dalam tatasusunan! Dan itulah sebabnya mereka menghasilkan Arrays.toString()kaedah — untuk memaparkan nilai tatasusunan. Kami memanggilnya seperti ini:

String str = Arrays.toString(name);

Contoh:

int[] array = {1, 2, 3};
String str = Arrays.toString(array);

"[1, 2, 3]"

int[] array = {};
String str = Arrays.toString(array);

"[]"

String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);

"[Hi, How's, life?]"

3.Arrays.deepToString()

Tetapi jika anda cuba menukar tatasusunan dua dimensi kepada kaedah rentetan (untuk memaparkannya) using the Arrays.toString(), anda akan melihat sesuatu yang biasa:

[I@37afeb11, I@37afeb21, I@37afeb31]

Ini semua kerana sel tatasusunan dua dimensi menyimpan rujukan kepada tatasusunan satu dimensi. Dan bagaimanakah tatasusunan satu dimensi ditukar kepada rentetan? Tepat seperti yang anda lihat di atas.

Apa yang boleh dibuat? Bagaimanakah kita memaparkan tatasusunan dua dimensi dengan betul?

Untuk tujuan ini, Arrayskelas mempunyai satu lagi kaedah khas — deepToString(). Memanggilnya kelihatan seperti ini:

String str = Arrays.deepToString(name);

Kaedah ini boleh menghantar tatasusunan yang dua dimensi, satu dimensi, tiga dimensi atau, secara umum, sebarang dimensi, dan ia akan sentiasa memaparkan unsur tatasusunan.
Nota: kaedah Arrays.deepToString()tidak berfungsi dengan tatasusunan satu dimensi primitif (contohnya, int[]).

Contoh:

Integer[] array = {1, 2, 3};
String str = Arrays.deepToString(array);

"[1, 2, 3]"

int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);

"[[1, 1], [2, 2], [3, 3]]"

int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);

"[[[1, 2, 3], [1]], [[]]]"

4.Arrays.equals()

Kami mengetahui cara untuk memaparkan tatasusunan pada skrin, tetapi bagaimana pula dengan membandingkan tatasusunan?

Untuk membandingkan rentetan, kita ada equalsdan equalsIgnoreCasekaedah, tetapi apakah kaedah yang ada pada tatasusunan?

Berita baiknya ialah tatasusunan mempunyai equalskaedah. Berita buruknya ialah ia tidak membandingkan kandungan tatasusunan. Kaedah equalstatasusunan melakukan perkara yang sama seperti ==pengendali - ia membandingkan rujukan. Contoh:

Contoh:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
boolean b = x1 == x2;

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

Apa yang boleh dibuat? Bagaimanakah kita membandingkan tatasusunan berdasarkan kandungannya?

Dan sekali lagi ia Arraysdatang untuk menyelamatkan kita, atau lebih khusus, kaedahnya Arrays.equals(). Inilah cara kami memanggilnya:

Arrays.equals(name1, name2)

Kaedah kembali truejika tatasusunan adalah sama panjang dan elemennya adalah sama. Jika tidak, ia kembali false.

Contoh:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);

5.Arrays.deepEquals()

Dan, seperti yang anda mungkin sudah meneka, Arrays.equalskaedah ini tidak akan berfungsi dengan betul untuk tatasusunan dua dimensi: ia memperlakukan tatasusunan dua dimensi seperti tatasusunan satu dimensi yang elemennya adalah alamat tatasusunan satu dimensi.

Oleh itu, untuk membandingkan tatasusunan berbilang dimensi dengan betul ( n = 1, 2, 3,...), mereka menghasilkan Arrays.deepEquals()kaedah tersebut. Memanggilnya kelihatan seperti ini:

Arrays.deepEquals(name1, name2)

Kaedah kembalitruejika tatasusunan adalah sama panjang dan elemennya adalah sama. Jika tidak, ia kembalifalse. Jika elemen di dalam tatasusunan juga tatasusunan, maka Arrays.deepEquals()kaedah digunakan untuk membandingkannya, dan seterusnya.

Contoh:

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
x1.equals(x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.equals(x1, x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.deepEquals(x1, x2);