Daftar di Groovy

1. Ikhtisar

Di Groovy, kita dapat bekerja dengan daftar seperti yang kita lakukan di Java. Tetapi, dengan dukungannya untuk metode ekstensi, ia dikirimkan dengan lebih banyak.

Dalam tutorial ini, kita akan melihat cara Groovy tentang mutasi, pemfilteran, dan pengurutan daftar.

2. Membuat Daftar Groovy

Groovy menyediakan pintasan menarik tertentu saat bekerja dengan koleksi yang memanfaatkan dukungannya untuk pengetikan dinamis dan sintaks literal.

Mari kita mulai dengan membuat daftar dengan beberapa nilai menggunakan sintaks singkat:

def list = [1,2,3]

Demikian pula, kita dapat membuat daftar kosong:

def emptyList = []

Secara default, Groovy membuat instance java.util.ArrayList. Namun, kami juga dapat menentukan jenis daftar yang akan dibuat :

def linkedList = [1,2,3] as LinkedList ArrayList arrList = [1,2,3]

Selanjutnya, daftar dapat digunakan untuk membuat daftar lain dengan menggunakan argumen konstruktor:

def copyList = new ArrayList(arrList)

atau dengan kloning:

def cloneList = arrList.clone()

Perhatikan bahwa kloning membuat salinan daftar yang dangkal.

Groovy menggunakan operator “==” untuk membandingkan elemen dalam dua daftar untuk persamaan. Melanjutkan contoh sebelumnya, saat membandingkan cloneList dengan arrlist , hasilnya benar:

assertTrue(cloneList == arrList)

Sekarang, mari kita lihat bagaimana melakukan beberapa operasi umum pada daftar.

3. Mengambil Item dari Daftar

Kita bisa mendapatkan item dari daftar menggunakan sintaks literal seperti:

def list = ["Hello", "World"] assertTrue(list[1] == "World")

atau menggunakan metode get () dan getAt () :

assertTrue(list.get(1) == "World") assertTrue(list.getAt(1) == "World")

Kami juga bisa mendapatkan item dari daftar menggunakan indeks positif dan negatif. Ketika indeks negatif digunakan, daftarnya dibaca dari kanan ke kiri:

assertTrue(list[-1] == "World") assertTrue(list.getAt(-2) == "Hello")

Perhatikan bahwa metode get () tidak mendukung indeks negatif.

4. Menambahkan Item ke Daftar

Ada beberapa cara cepat untuk menambahkan item ke daftar. Mari tentukan daftar kosong dan tambahkan beberapa item ke dalamnya:

def list = [] list << 1 list.add("Apple") assertTrue(list == [1, "Apple"])

Selanjutnya, kita juga dapat menentukan indeks untuk menempatkan item. Selain itu, jika panjang daftar kurang dari indeks yang ditentukan, Groovy menambahkan nilai null sebanyak perbedaannya :

list[2] = "Box" list[4] = true assertTrue(list == [1, "Apple", "Box", null, true])

Terakhir, kita dapat menggunakan operator “ + =” untuk menambahkan item baru ke daftar. Dibandingkan dengan pendekatan lain, operator ini membuat objek daftar baru dan menugaskannya ke daftar variabel :

def list2 = [1,2] list += list2 list += 12 assertTrue(list == [1, 6.0, "Apple", "Box", null, true, 1, 2, 12])

5. Memperbarui Item dalam Daftar

Kita dapat memperbarui item dalam daftar menggunakan sintaks literal atau metode set () :

def list =[1, "Apple", 80, "App"] list[1] = "Box" list.set(2,90) assertTrue(list == [1, "Box", 90, "App"])

Dalam contoh ini, item di indeks 1 dan 2 diperbarui dengan nilai baru.

6. Menghapus Item dari Daftar

Kita bisa menghapus item pada indeks tertentu menggunakan metode remove () :

def list = [1,2,3,4,5,5,6,6,7] list.remove(3) assertTrue(list == [1,2,3,5,5,6,6,7])

Atau kita juga bisa menghapus elemen dengan menggunakan metode removeElement () . Ini menghapus kemunculan pertama elemen dari daftar:

list.removeElement(5) assertTrue(list == [1,2,3,5,6,6,7])

Selain itu, kita dapat menggunakan operator minus untuk menghapus semua kemunculan elemen dari daftar . Operator ini, bagaimanapun, tidak mengubah daftar yang mendasarinya - ini mengembalikan daftar baru:

assertTrue(list - 6 == [1,2,3,5,7])

7. Iterasi pada Daftar

Groovy telah menambahkan metode baru ke Java Collections API yang ada. Metode ini menyederhanakan operasi seperti pemfilteran, pencarian, pengurutan, agregasi, dll dengan mengenkapsulasi kode boilerplate. Juga mereka mendukung berbagai masukan termasuk penutupan dan struktur data keluaran.

Mari kita mulai dengan melihat dua metode untuk mengulang daftar.

Metode each () menerima penutupan dan sangat mirip dengan metode foreach () di Java. Groovy melewati parameter implisit itu yang sesuai dengan elemen saat ini di setiap iterasi:

def list = [1,"App",3,4] list.each {println it * 2}

Metode lainnya, eachWithIndex () memberikan nilai indeks saat ini selain elemen saat ini:

list.eachWithIndex{ it, i -> println "$i : $it" }

8. Penyaringan

Pemfilteran adalah operasi lain yang sering dilakukan pada daftar, dan Groovy menyediakan banyak metode berbeda untuk dipilih.

Mari tentukan daftar untuk dioperasikan:

def filterList = [2,1,3,4,5,6,76]

Untuk menemukan objek pertama yang cocok dengan kondisi kita dapat menggunakan find :

assertTrue(filterList.find {it > 3} == 4)

Untuk menemukan semua objek yang cocok dengan kondisi kita bisa menggunakan findAll :

assertTrue(filterList.findAll {it > 3} == [4,5,6,76])

Mari kita lihat contoh lainnya. Di sini, kami ingin daftar semua elemen yang berupa angka:

assertTrue(filterList.findAll {it instanceof Number} == [2,1,3,4,5,6,76])

Sebagai alternatif, kita dapat menggunakan metode grep untuk melakukan hal yang sama:

assertTrue(filterList.grep( Number ) == [2,1,3,4,5,6,76])

Perbedaan antara metode grep dan find adalah bahwa grep dapat menerima Objek atau Penutupan sebagai argumen. Dengan demikian, ini memungkinkan pengurangan lebih lanjut pernyataan kondisi ke minimal:

assertTrue(filterList.grep {it > 6} == [76])

Selain itu, grep menggunakan Object # isCase (java.lang.Object) untuk mengevaluasi kondisi pada setiap elemen daftar.

Terkadang kami mungkin hanya tertarik pada item unik dalam daftar . Ada dua metode kelebihan beban yang dapat kita gunakan untuk tujuan ini.

Metode unique () secara opsional menerima closure dan menyimpan dalam daftar pokok hanya elemen yang cocok dengan kondisi closure sambil membuang yang lain. Ini menggunakan pengurutan alami secara default untuk menentukan keunikan:

def uniqueList = [1,3,3,4] uniqueList.unique() assertTrue(uniqueList == [1,3,4])

Alternatifnya, jika persyaratannya bukan untuk mengubah daftar yang mendasarinya, maka kita bisa menggunakan metode toUnique () :

assertTrue(["A", "B", "Ba", "Bat", "Cat"].toUnique {it.size()} == ["A", "Ba", "Bat"])

Jika kita ingin memeriksa bahwa beberapa atau semua item dalam daftar memenuhi kondisi tertentu, kita dapat menggunakan metode every () dan any () .

Metode every () mengevaluasi kondisi di closure terhadap setiap elemen dalam daftar. Kemudian, ini hanya mengembalikan nilai true jika semua elemen dalam daftar memenuhi ketentuan:

def conditionList = [2,1,3,4,5,6,76] assertFalse(conditionList.every {it < 6})

Di sisi lain, metode any () mengembalikan nilai true jika ada elemen dalam daftar yang memenuhi kondisi:

assertTrue(conditionList.any {it % 2 == 0})

9. Menyortir

Secara default, Groovy mengurutkan item dalam daftar berdasarkan urutan aslinya:

assertTrue([1,2,1,0].sort() == [0,1,1,2])

Tapi kita juga bisa meneruskan Comparator dengan logika pengurutan khusus :

Comparator mc = {a,b -> a == b? 0: a < b? 1 : -1} def list = [1,2,1,0] list.sort(mc) assertTrue(list == [2,1,1,0])

Selain itu, kita dapat menggunakan metode min () atau max () untuk menemukan nilai maksimum atau minimum tanpa secara eksplisit memanggil sort ():

def strList = ["na", "ppp", "as"] assertTrue(strList.max() == "ppp")
Comparator minc = {a,b -> a == b? 0: a < b? -1 : 1} def numberList = [3, 2, 0, 7] assertTrue(numberList.min(minc) == 0)

10. Mengumpulkan

Kadang-kadang kami mungkin ingin mengubah item dalam daftar dan mengembalikan daftar lain dengan nilai yang diperbarui. Ini bisa dilakukan dengan menggunakan metode collect () :

def list = ["Kay","Henry","Justin","Tom"] assertTrue(list.collect{"Hi " + it} == ["Hi Kay","Hi Henry","Hi Justin","Hi Tom"])

11. Bergabung

Kadang-kadang, kita mungkin perlu menggabungkan item dalam daftar. Untuk melakukan itu kita dapat menggunakan metode join () :

assertTrue(["One","Two","Three"].join(",") == "One,Two,Three")

12. Kesimpulan

Pada artikel ini, kami membahas beberapa ekstensi yang ditambahkan Groovy ke Java Collections API.

Kami memulai dengan melihat sintaks literal dan kemudian penggunaannya dalam membuat, memperbarui, menghapus, dan mengambil item dalam daftar.

Terakhir, kami melihat dukungan Groovy untuk iterasi, pemfilteran, pencarian, pengumpulan, penggabungan, dan pengurutan daftar.

Seperti biasa, semua contoh yang dibahas dalam artikel tersedia di GitHub.