Tatasusunan — kelas pembantu

"Amigo, saya harap sekarang anda telah menyedari betapa berguna tatasusunan dalam pengaturcaraan?"

"Paling pasti, Rishi! Saya sudah menyelesaikan lebih daripada satu tugas."

"Adakah tugas anda mempunyai tindakan berulang? Jenis yang telah anda lakukan berulang kali."

"Jika saya memahami anda dengan betul, anda maksudkan tindakan yang serupa dalam tugasan yang berbeza? Contohnya, di mana-mana menggunakan gelung untuk memaparkan kandungan tatasusunan — saya sangat bosan melakukan itu!"

"Ya, itulah yang saya maksudkan. Pencipta Java mendapati bahawa pengaturcara Java sering menulis kod yang sama apabila bekerja dengan tatasusunan. Contohnya, kod untuk menyalin sebahagian daripada tatasusunan ke tatasusunan lain, atau kod untuk mengisi setiap sel tatasusunan dengan tatasusunan yang sama. nilai. Atau contoh anda: kod untuk memaparkan kandungan tatasusunan dalam bentuk yang boleh dibaca pada skrin.

"Dan pengaturcara sebenar mempunyai satu peraturan yang sangat penting: jangan ulangi diri sendiri. Anda akan bersetuju bahawa adalah salah untuk melakukan kerja yang berlebihan — anda tidak akan dibayar untuk itu. Kerja yang berkesan dibayar dengan baik, percayalah. Kebetulan, seorang pemula kod segera dikenali dengan jumlah kod berulang yang banyak.

"Pencipta Java memikirkan perkara ini, dan mencipta Arrayskelas khas (nama penuhnya ialah java.util.Arrays), meletakkan tindakan berkaitan tatasusunan yang paling popular ke dalamnya."

“Hmm... Sangat menarik. Jadi apa sebenarnya yang ada padanya?

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

Arrays.toString()

"Kaedah pertama yang kita akan lihat ialah 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. Amigo, adakah anda telah cuba mencetak tatasusunan ke skrin menggunakan kaedah itu?System.out.println(name)

Saya mengaku, itu memang berlaku. Saya melihat beberapa omong kosong. Saya memutuskan untuk menjauhi bahaya dan terus menggunakan gelung.

"Kemungkinan besar anda melihat sesuatu seperti:

I@37afeb11

"Huruf pertama Ibermaksud bahawa ia adalah inttatasusunan, dan simbol selepasnya @ialah alamat objek tunggal dalam ingatan. Anda boleh menganggapnya sebagai alamat tatasusunan dalam ingatan. Di satu pihak, ini tepatnya maklumat yang disimpan dalam pembolehubah tatasusunan, tetapi sebaliknya, anda menjangkakan sesuatu yang berbeza, bukan?"

"Tepat sekali! Saya merancang untuk melihat nilai dalam tatasusunan. Ini adalah perkara terakhir yang saya jangkakan."

"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);

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

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

Arrays.deepToString()

"Walau bagaimanapun, toString()kaedah ini tidak mencukupi apabila ia melibatkan tatasusunan dua dimensi. Dalam erti kata lain, jika anda cuba memanggil 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 bagaimana tatasusunan satu dimensi ditukar kepada rentetan? Tepat seperti yang anda lihat di atas.

"Apa yang perlu dilakukan kemudian? Bagaimanakah cara kita memaparkan tatasusunan dua dimensi dengan betul?"

"Pencipta Java juga menjangkakan perkara ini. 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.

Contoh:

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

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

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

Arrays.equals()

"Kami telah mengetahui cara untuk memaparkan tatasusunan pada skrin. Bagaimana pula dengan membandingkan tatasusunan? Adakah anda masih ingat kaedah yang boleh kami gunakan untuk membandingkan rentetan?"

"Saya biasanya menggunakan equalskaedah itu!

"Ya, equals, dan juga equalsIgnoreCase(yang membandingkan rentetan tanpa mengambil kira huruf besar dan huruf kecil).

"Berita baik: anda juga boleh menggunakan equalskaedah untuk tatasusunan. Berita buruk: ia tidak membandingkan kandungan tatasusunan. Kaedah equalstatasusunan melakukan perkara yang sama seperti ==operator - ia membandingkan rujukan.

Contoh:

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

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

"Jadi apa yang kita lakukan? Bagaimanakah kita membandingkan tatasusunan berdasarkan kandungannya?"

"Sekali lagi Arrayskelas datang untuk menyelamatkan kami. Lebih khusus lagi, kaedahnya Arrays.equals(). Beginilah kami memanggilnya:

Arrays.equals(name1, name2)

"Kaedah ini kembali truejika tatasusunan adalah sama panjang dan elemennya adalah sama. Jika tidak, ia mengembalikan 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);

Arrays.deepEquals()

"Dan, seperti yang anda mungkin sudah meneka, Arrays.equalskaedah itu tidak akan berfungsi dengan betul untuk tatasusunan dua dimensi: ia merawat 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. Memanggilnya kelihatan seperti ini:

Arrays.deepEquals(name1, name2)

"Kaedah ini kembali truejika 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);

"Terima kasih, Rishi! Pelajaran ini adalah apa yang saya perlukan untuk menjadikan hidup saya lebih mudah dan bahagia pada masa hadapan. Sekarang saya akan menggunakan kaedah kelas Arrays dan menulis program saya dengan lebih cepat.

"Itulah yang saya harapkan, ha-ha. Tetapi ini bukan semua kaedah yang menarik dalam kelas Arrays. Saya akan memberitahu anda tentang orang lain lain kali."