Kelas tatasusunan dan penggunaannya

Hello lagi! :) Dalam pelajaran lepas, kami berkenalan dengan struktur data seperti tatasusunan (tatasusunan Java), belajar cara membuat tatasusunan, mengisinya dengan data, dan juga mempelajari cara ia disimpan dalam ingatan. Hari ini kita akan melihat beberapa tugasan dan contoh bekerja dengan tatasusunan yang sering anda hadapi dalam kerja sebenar. Sebagai contoh, bayangkan situasi ini: kami mempunyai tatasusunan 10 nombor yang ditulis dalam susunan rawak.

//array Java, example
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Tugas kami ialah mengisih tatasusunan ini dalam tertib menaik: daripada nombor terkecil kepada nombor terbesar. Pada akhirnya ia sepatutnya kelihatan seperti ini:

[-234, -2, 16, 26, 35, 43, 80, 92, 99, 167]

Bagaimana kita melakukan ini? Tugas itu bukan remeh, kami tidak pernah melakukan ini sebelum ini :/ Ada idea? Cuba teka. Inilah yang boleh kita lakukan, sebagai contoh:

• Lelaran melalui semua elemen tatasusunan. Bandingkan setiap elemen dengan yang seterusnya ( [0]dengan [1], [1]dengan [2], [2]dengan , [3]dsb.). Jika elemen tatasusunan semasa lebih besar daripada yang seterusnya, kami menukarnya dan beralih ke elemen seterusnya. Jika tidak, biarkan ia seperti sedia ada dan teruskan.


• Oleh itu, selepas laluan pertama melalui elemen tatasusunan, nilai terbesar (167) dijamin berada dalam sel terakhir.


• Sekarang mari kita pergi melalui semua elemen tatasusunan sekali lagi, bermula dengan elemen dengan index [0], tetapi sehingga elemen kedua terakhir (nombor terbesar sudah berada di tempatnya) dan buat perbandingan dan pertukaran yang sama. 
  Pada akhirnya, dalam sel kedua terakhir kita akan mempunyai nilai kedua tertinggi (99).


• Mari kita ulangi kerja ini seberapa banyak yang kita mempunyai tolak satu elemen dalam tatasusunan.

Kami datang dengan idea, yang tinggal hanyalah menulis kod. Ia akan kelihatan seperti ini:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       for (int i = numbers.length - 1; i > 0; i--) {
           for (int j = 0; j < i; j++) {
           /* Compare the elements in pairs,
             if they are in the wrong order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

Um... Nampak rumit sedikit -_- Walaupun prinsip operasi amnya jelas, anda perlu menulis kod yang agak banyak untuk menyelesaikan tugasan yang kelihatan mudah itu. Baiklah, mungkin kita hanya melebihkan diri kita sendiri? Mungkin, tugas yang kami pikul terlalu sukar untuk kami setakat ini. Mari cuba lakukan sesuatu yang lebih mudah. Sebagai contoh, mari kita ambil susunan nombor yang sama.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Tugas kami ialah menyalin kandungannya ke tatasusunan lain.

int [] numbersCopy = new int[10];

Fikirkan bagaimana anda akan melakukan ini menggunakan pengetahuan tentang tatasusunan yang sudah anda miliki? Anda boleh, sebagai contoh, menggelungkan tatasusunan numbersdan menulis elemennya satu demi satu ke dalam numbersCopy:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = new int[10];

       for (int i = 0; i < numbers.length; i++) {

           numbersCopy[i] = numbers[i];
       }

   }
}

Nah, lebih kurang kami telah melakukannya! Masalahnya nampaknya telah diselesaikan, tetapi sekali lagi: jika ia perlu dilaksanakan dengan kerap, kod itu akan mempunyai sekumpulan gelung yang sama. Sebenarnya, ini dan masalah lain telah lama diselesaikan oleh pencipta Java, dan kami tidak perlu "mencipta semula roda" dan menulis beberapa kod untuk penyelesaian kami sendiri.

Kelas Tatasusunan Java

Kelas Java khas akan membantu anda menyelesaikan masalah biasa apabila bekerja dengan tatasusunan - Arrays. Kaedah telah ditambahkan pada kelas ini untuk menyelesaikan masalah paling biasa yang dihadapi oleh pengaturcara Java dalam kerja mereka. Sebagai contoh, tugas menyusun tatasusunan, yang mana kami sendiri cuba menghasilkan penyelesaian, boleh diselesaikan dalam satu baris:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       Arrays.sort(numbers);

       System.out.println(Arrays.toString(numbers));

   }
}

Kaedah Arrays.sort()menyusun tatasusunan. Selain itu, algoritma yang tertanam di dalamnya menjadikan ini lebih cekap daripada kod yang kami tulis. Output konsol:

[-234, -2, 16, 26, 35, 43, 80, 92, 99, 167]

Sila ambil perhatian: untuk menukar tatasusunan kepada rentetan, kami menggunakan kaedah kelas lain Arrays- Arrays.toString(). Tatasusunan Java sendiri tidak mengatasi toString(). Jadi jika anda hanya menulis

System.out.println(numbers.toString());

toString()kaedah kelas akan dipanggil Object. Dalam kes tatasusunan, output akan menjadi seperti ini:

[I@4554617c

Sekarang kita tidak akan menjelaskan secara terperinci mengapa kesimpulannya seperti ini; perkara utama ialah ini jelas bukan yang kita perlukan. Tetapi Arrays.toString() melakukan apa yang kami mahu. Ngomong-ngomong, masalah kami dengan menyalin juga mudah diselesaikan di dalam kelas Arrays:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Kepada kaedah Arrays.copyOf()kami lulus tatasusunan asal kami (dari mana kami perlu menyalin nilai) dan panjang tatasusunan baharu yang kami salin data. Dalam kes ini, kami menunjukkan sebagai panjang numbers.length, kerana kami mahu menyalin keseluruhan tatasusunan. Jika kita ingin menyalin hanya beberapa elemen pertama, kita boleh menentukan panjang yang lebih kecil untuk tatasusunan baharu:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Di sini kami telah menentukan panjang tatasusunan baharu menjadi 4. Oleh itu, hanya 4 elemen pertama numbersakan disalin ke tatasusunan baharu. Output konsol:

[167, -2, 16, 99]

Dengan cara ini, jika anda perlu menyalin sebahagian daripada tatasusunan, tetapi bukan dari awal, tetapi "dari tengah," Arraysanda juga boleh melakukan ini:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Kesimpulan:

[16, 99, 26, 92]

Nombor dari sel dua ( termasuk ) hingga enam ( tidak termasuk ) telah disalin ke dalam tatasusunan baharu. Di samping itu, kita mungkin perlu membandingkan dua tatasusunan antara satu sama lain. Sama seperti kaedah toString(), tatasusunan sendiri tidak mengatasi kaedah equals(). Jadi jika kita cuba membandingkannya seperti ini:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(numbers.equals(numbers2));
   }
}

kita dapat hasilnya false. Object.equals()Lagipun, kaedah yang membandingkan pautan akan dipanggil . Dan sudah tentu mereka berbeza! Tetapi kita perlu membandingkan kandungan tatasusunan, bukan pautan. Kelas Arraysmengandungi kaedah ganti equals()yang melakukan apa yang kita perlukan:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(Arrays.equals(numbers, numbers2));
   }
}

Kesimpulan:

true

Dengan cara ini, kelas Arraysberfungsi dengan jayanya bukan sahaja dengan tatasusunan biasa, tetapi juga dengan tatasusunan dua dimensi:

public class Main {

   public static void main(String[] args) {

       int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

       int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);

       System.out.println("Are these two-dimensional arrays equal to each other?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));

       System.out.println(Arrays.deepToString(numbersCopy));
   }
}

Kesimpulan:

Равны ли эти двумерные массивы между собой?
true
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Seperti yang anda lihat, kaedah ini Arrays.copyOf()mengatasi dengan menyalin tatasusunan dua dimensi. Sila ambil perhatian bahawa dalam kes ini, apabila menyalin tatasusunan dua dimensi, apa yang dipanggil "salinan cetek" berlaku. Dan untuk membandingkan tatasusunan dua dimensi dan mengeluarkannya ke konsol, kaedah khas disediakan - deepEqualsdan deepToString(); Pada masa hadapan, anda akan melihat lebih daripada sekali (dan gembira mengenainya) bahawa pencipta Java meramalkan banyak situasi tipikal yang dihadapi oleh pengaturcara semasa bekerja, dan melaksanakan penyelesaian siap sedia untuk mereka dalam bahasa. Menggunakan penyelesaian ini adalah lebih mudah dan lebih mudah daripada mencipta semula roda, bukan? :) Pastikan anda membaca dokumentasi kelas Arraysdi laman web Oracle . Semoga berjaya dengan pelajaran anda!