Secara umum, struktur data dalam buku teks meliputi array, daftar tertaut tunggal, tumpukan, pohon, dan grafik. Struktur data yang saya maksudkan di sini adalah pertanyaan tentang bagaimana mewakili suatu objek. Kadang-kadang, deklarasi variabel tunggal tidak berguna, seperti int, string, ganda, atau bahkan array satu dimensi dan array dua dimensi tidak dapat sepenuhnya mengekspresikan apa yang ingin Anda ungkapkan, dan terlalu merepotkan untuk mendefinisikan kelas kelas. Saat ini, Anda dapat mempertimbangkan menggunakan kelas koleksi di Java. Menggunakan kelas koleksi, Anda harus menyatakan impor java.util.* Di header file;
1. Dinamis, Terdinam,, Variabel Berukuran Vektor Array Satu Dimensi dan Daftar Array
Kelas koleksi termasuk vektor array dan array satu dimensi dinamis, dipesan, dan berukuran variabel.
Satu -satunya perbedaan antara Vektor dan ArrayList adalah: Vektor dilengkapi dengan utas yang saling eksklusif, dan banyak utas akan melempar pengecualian untuk dibaca dan ditulis, sementara ArrayList memungkinkan banyak utas untuk dibaca dan ditulis, dan bagian -bagian lainnya persis sama. Dengan kata lain, jika satu utas membaca dan menulis, tidak ada perbedaan antara menggunakan vektor dan arraylist, tetapi sekarang pemrograman pada dasarnya adalah arraylist, dan menggunakan vektor sedikit non-mainstream.
1. Penggunaan vektor adalah sebagai berikut:
public static void vectortest () {// vector <mouble> berarti bahwa vektor ini hanya dapat menyimpan ganda // vektor <string> berarti bahwa vektor ini hanya dapat menyimpan string // meskipun vektor <appect> vector = vektor baru <appor> (); setara dengan vektor vektor = baru // vektor (); Namun, menulis ini di Eclipse akan memperingatkan Anda, menunjukkan bahwa vektor Anda tidak standar, () vektor <papure> vektor = vektor baru <Papen> (); vector.add (1.6); vector.add (2.06); vector.add (1); System.out.println ("Tambah Sederhana berarti menambahkan elemen dari akhir:" + vektor); System.out.println ("size () dapat menemukan jumlah elemen yang terkandung dalam vektor:" + vector.size ()); vektor.remove (1); System.out.println ("Hapus (1) berarti menghapus elemen pertama, karena jumlah dimulai dari 0, yaitu, elemen 2.06:" + vektor); vector.remove (vector.lastelement ()); System.out.println ("Vektor yang menghapus elemen terakhir adalah:" + vektor); vector.add (0, 1.8888); System.out.println ("Tambahkan 1.8888 elemen ini pada posisi ke -0:" + vektor); vector.set (0, "a"); System.out.println ("Ubah posisi ke -0:" + vektor); } Jika metode ini dipanggil dalam fungsi utama:
System.out.println ("======== Tes Mulai dari struktur data vektor ============"); Vectortest (); System.out.println ("======== Uji akhir struktur data vektor ==============); Hasil operasi adalah sebagai berikut:
======= Tes Mulai dari struktur data vektor ======
Tambah sederhana berarti menambahkan elemen dari akhir: [1.6, 2.06, 1]
size () dapat menemukan jumlah elemen yang terkandung dalam vektor: 3
Hapus (1) berarti menghapus elemen pertama. Karena jumlah dimulai dari 0, yaitu, elemen 2.06: [1.6, 1]
Vektor yang menghapus elemen terakhir adalah: [1.6]
Tambahkan elemen 1.8888 pada posisi 0: [1.8888, 1.6]
Ubah elemen pada posisi 0 ke A: [a, 1.6]
======== Uji akhir struktur data vektor ======
2. ArrayList
public static void arrayListTest () {arraylist <mouble> arrayList = new ArrayList <double> (); arraylist.add (1.0); arraylist.add (4.0); arraylist.add (5.0); arraylist.add (2.3); System.out.println ("Simple Add berarti menambahkan elemen dari akhir:" + ArrayList); System.out.println ("size () dapat menemukan jumlah elemen yang terkandung:" + arraylist.size ()); arraylist.remove (1); System.out.println ("Hapus (1) berarti menghapus elemen pertama. Karena jumlah dimulai dari 0, yaitu, elemen 4:" + arraylist); arraylist.remove (arraylist.size () - 1); System.out.println ("Daftar Array untuk Menghapus Elemen Terakhir adalah:" + ArrayList); arraylist.add (0, 1.8888); System.out.println ("Tambahkan elemen 1.8888 pada posisi 0:" + ArrayList); arraylist.set (0, 9.0); System.out.println ("Ubah elemen pada posisi 0 ke A:" + ArrayList); Collections.sort (arraylist); System.out.println ("Penyortiran didukung jika ArrayList bukan tipe abstrak" + ArrayList); } Di sini Anda dapat melihat bahwa cara ArrayList menghapus elemen terakhir berbeda dari vektor. Alasan utama adalah bahwa ArrayList tidak memiliki metode LastElement () untuk menghapus elemen terakhir. Lepas () hanya dapat digunakan untuk menentukan posisi elemen terakhir. Jika metode ini dipanggil dalam fungsi utama seperti ini:
System.out.println ("========= Tes Mulai dari struktur data arraylist =========="); Arraylisttest (); System.out.println ("======== Uji akhir Struktur Data ArrayList =================); Maka hasil berjalan berikut diperoleh:
======= Tes Mulai dari struktur data arraylist ======
Tambah sederhana berarti menambahkan elemen dari akhir: [1.0, 4.0, 5.0, 2.3]
size () dapat menemukan jumlah elemen yang terkandung: 4
Hapus (1) berarti menghapus elemen pertama. Karena jumlah dimulai dari 0, yaitu, elemen 4: [1.0, 5.0, 2.3]
Daftar Array untuk Menghapus Elemen Terakhir adalah: [1.0, 5.0]
Tambahkan elemen 1.8888 pada posisi 0: [1.8888, 1.0, 5.0]
Ubah elemen pada posisi 0 ke A: [9.0, 1.0, 5.0]
Jika ArrayList bukan tipe abstrak, penyortiran didukung [1.0, 5.0, 9.0]
======== Uji akhir struktur data arraylist ======
Dari dua contoh di atas, kita dapat melihat bahwa vektor dan arraylist lebih dari sekadar array biasa, yaitu, array satu dimensi yang diajarkan dalam buku teks int array [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; itu jauh lebih kuat. Anda dapat memasukkan elemen pada posisi apa pun, atau Anda dapat menghapus elemen pada posisi yang ditentukan tanpa melintasi array. Tentu saja, Anda masih perlu tahu bagaimana array ini dilalui untuk Anda. Faktanya, arraylist dan array satu dimensi biasa dapat sepenuhnya diubah, dan arraylist juga dapat digunakan untuk mengurutkan array secara langsung tanpa menulis semacam gelembung pada array. Anda dapat mengurutkan array secara langsung dengan collections.sort (); dan kemudian gunakan collections.reverse (); untuk mencapai penyortiran terbalik. Tentu saja, itu masih merupakan kalimat yang sama. Untuk Anda, Anda masih perlu tahu bagaimana array ini diurutkan.
Sebagai contoh, metode berikut mengimplementasikan penyortiran dan penyortiran terbalik array array satu dimensi [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; pertama kali mengubah array menjadi arraylist dan kemudian mengurutkannya dengan collections.sort (); dan collections.reverse ();, dan akhirnya mengonversi konten arraylist kembali ke array satu dimensi:
public static void arrayListSort () {int array [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; ArrayList <Integer> arrayList = ArrayList baru <Integer> (); untuk (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); untuk (int i = 0; i <array.length; i ++) arraylist.add (array [i]); Collections.sort (arraylist); untuk (int i = 0; i <array.length; i ++) arraylist.add (array [i]); Collections.sort (arraylist); untuk (int i = 0; i <array.length; i <array.length; i ++) arraylist.add (array [i]); Collections.sort (arraylist); untuk (int i = 0; i <array.length; i <array.length; i ++) arraylist.add (array [i]); Collections.sort (arraylist); untuk (int i = 0; i <array.length; i ++) array [i] = arraylist.get (i); System.out.print ("Sorted Array:"); untuk (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); Collections.Reverse (ArrayList); untuk (int i = 0; i <array.length; i ++) array [i] = arraylist.get (i); System.out.print ("Array yang diurutkan terbalik:"); untuk (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); // Hancurkan daftar array setelah menyortir. ArrayList = null; // Kalimat ini menunjukkan bahwa java mendaur ulang sampah segera. Tentu saja, apakah kalimat ini baik -baik saja atau tidak, Java akan secara otomatis menghilangkan sampah selama proses lari; } Dalam fungsi utama, metode ini disebut seperti ini:
System.out.println ("========== Java Array Sort dimulai ============"); arraylistsort (); System.out.println ("============= Java Array Sort berakhir ===========); Anda bisa mendapatkan hasil berjalan berikut:
======== Java Array Sorting dimulai ======
8,7,100,88,6,4,5,33,7, diurutkan Array: 4,5,6,7,7,8,33,88,100, array yang diurutkan terbalik: 100,88,33,7,7,6,5,4,
========= Java Array Sortting berakhir ======
Selain itu, hal yang sama berlaku untuk "pengantar singkat sebelumnya untuk penggunaan daftar di java" (klik untuk membuka tautan)
2. Hashset koleksi
Selain itu, ada koleksi hashset, yang persis sama dengan konsep koleksi matematika. Satu set yang terdiri dari satu atau lebih elemen disebut satu set. Hashset memiliki:
1. Determinisme . Elemen dalam set harus deterministik. Ini omong kosong. Itu harus deterministik. Bisakah saya tetap memasukkan hal yang tidak pasti di dalamnya?
2. Lawan lawan jenis , elemen -elemen dalam set berbeda. Misalnya: Atur a = {1, a}, maka a tidak dapat sama dengan 1, yaitu, jika Anda memasukkan dua 1 ke dalam hashset, itu akan secara otomatis menjadi 1
3. Gangguan , tidak ada urutan elemen di set. Oleh karena itu, hashset tidak boleh melakukan operasi penyortiran, misalnya, metode berikut:
public static void hashSetTest () {hashset <baption> hashset = hashset baru <apbes> (); hashset.add (1); hashset.add (1); hashset.add (5); hashset.add (2.3); System.out.println ("Simple Add berarti menambahkan elemen dari akhir:" + HashSet); System.out.println ("size () dapat menemukan jumlah elemen yang terkandung:" + hashset.size ()); hashset.remove (1); System.out.println ("Hapus (1) berarti menghapus elemen '1':" + hashset); hashset.remove ("ASD"); System.out.println ("Jika tidak ada elemen 'ASD', hapus tidak melakukan apa -apa:" + hashset); hashset.add (1.8888); System.out.println ("Tambahkan Elemen 1.8888:" + Hashset); }Di fungsi utama, panggil metode ini:
System.out.println ("========= Tes Mulai dari Struktur Data Hashset =========="); HashSettest (); System.out.println ("========= Uji Uji Struktur Data Hashset =================); Hasilnya adalah sebagai berikut:
======= Tes dimulai dengan struktur data hashset ======
Tambah sederhana berarti menambahkan elemen dari akhir: [1, 5, 2.3]
size () dapat menemukan jumlah elemen yang terkandung: 3
hapus (1) berarti menghapus elemen '1': [5, 2.3]
Tanpa elemen 'ASD', hapus tidak melakukan apa -apa: [5, 2.3]
Tambahkan elemen 1.8888: [5, 1.8888, 2.3]
======== Uji akhir struktur data hashset ======
Hashset memiliki metode add () dan metode lepas (). Elemen yang ditambahkan ke ADD () sedang berurutan. Hasil yang dicetak dengan System.out.println () mungkin dalam pesanan yang berbeda. Mereka tidak bisa sama dengan vektor dan daftar array di atas. Selama elemen yang disimpan bukan objek, collections.sort (arraylist); dapat digunakan untuk mengurutkannya.
3. Hashmap ganda
Metode penggunaan di sini pada dasarnya sama dengan data di atas, dan juga sangat sederhana. Ini untuk memasukkan objek ke dalam peta, dan dapat mengambil objek di peta, tetapi salah untuk mencoba menggunakan hashmap biner ke dalam tiga kali lipat. Jika suatu objek berisi terlalu banyak elemen, Anda harus mempertimbangkan untuk menggunakan kelas. Alih -alih terobsesi dengan kelas koleksi Java yang mengganggu antara variabel biasa dan kelas kelas.
Misalnya, metode berikut menunjukkan operasi kesalahan mencoba mengubah hashmap menjadi tiga:
public static void Maptest(){ System.out.println("============ Start of use of Map error==============); HashMap<String,String> map=new HashMap<String, String>(); HashMap<String,HashMap<String, String>> bigmap=new HashMap<String, HashMap<String, String (); System.out.println (BigMap.get ("Test1"). Get ("Key1")); System.out.println (BigMap.get ("Test2"). Get ("Key2")); salah ========================================================================================================================================= ================================================================ ================================================================= ================================================================ ================================================================= ================================================================= ================================================================= Memanggil kode ini di fungsi utama memberikan hasil lari berikut:
======== Tes dimulai dengan struktur data peta ======
======== Mulai penggunaan kesalahan peta ======
{test1 = {key2 = 4, key1 = 3}, test2 = {key2 = 4, key1 = 3}}
3
4
3
4
======= Akhir penggunaan kesalahan peta ======
========= Mulai penggunaan peta yang benar ======
{key3 = 3, key2 = 2, key1 = 1}
======== Akhir dari penggunaan peta yang benar ======
======== Uji akhir struktur data peta ======
Program ini awalnya dimaksudkan untuk menjadi sangat jelas, mencoba membangun {test1, key1,1}, {test1, key2,2}, {test2, key3,3}, {test2, key4,4}
Namun, setiap BigMap masih memiliki peta itu. Setelah Anda menghapus peta, peta di Test1 juga akan dihapus. Seseorang mencoba membuat beberapa MAP1, MAP2, ... maka Anda mungkin juga menggunakan kelas sederhana untuk terlihat lebih jelas, dan Anda dapat menulis metode di kelas di masa depan dan diwariskan
4. Catatan
Saat membuat vektor baru, arraylist, hashset, atau hashmap, Anda dapat menulisnya sebagai:
Koleksi <string> a = ArrayList baru <string> ();
Daftar <string> a = vektor baru <string> ();
Karena ada daftar array, vektor, linkedlist, hashset, dan treeset yang mewarisi dari antarmuka pengumpulan, dan hashmap dan hashtable yang mewarisi dari antarmuka peta, ini adalah masalah warisan, polimorfisme, enkapsulasi dan kelas lain di Java. Tentu saja, bagi teman Anda untuk melihat lebih jelas, jangan memainkan penamaan mewah di sini, tulis arraylist yang jelas <Integer> arrayList = new ArrayList <Integer> (); Tidak ada yang berani mengatakan bahwa Anda tidak memahami kelas di Java.
Di atas adalah semua konten artikel ini. Saya berharap ini akan membantu untuk pembelajaran semua orang dan saya harap semua orang akan lebih mendukung wulin.com.