Senarai di Groovy

1. Gambaran keseluruhan

Di Groovy, kita dapat bekerja dengan senarai seperti yang kita lakukan di Java. Tetapi, dengan sokongan untuk kaedah peluasan, ia dihantar dengan sedikit lebih banyak.

Dalam tutorial ini, kita akan melihat bagaimana Groovy melakukan mutasi, menyaring dan menyusun senarai.

2. Membuat Senarai Groovy

Groovy menyediakan jalan pintas yang menarik ketika bekerja dengan koleksi yang menggunakan sokongannya untuk menaip dinamik dan sintaks literal.

Mari mulakan dengan membuat senarai dengan beberapa nilai menggunakan sintaks pendek:

def list = [1,2,3]

Begitu juga, kita boleh membuat senarai kosong:

def emptyList = []

Secara lalai, Groovy membuat contoh java.util.ArrayList. Walau bagaimanapun, kami juga dapat menentukan jenis senarai yang akan dibuat :

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

Seterusnya, senarai boleh digunakan untuk membuat senarai lain dengan menggunakan argumen konstruktor:

def copyList = new ArrayList(arrList)

atau dengan pengklonan:

def cloneList = arrList.clone()

Perhatikan bahawa pengklonan membuat salinan senarai yang cetek.

Groovy menggunakan operator "==" untuk membandingkan elemen dalam dua senarai untuk kesamaan. Teruskan dengan contoh sebelumnya, untuk membandingkan cloneList dengan arrlist hasilnya benar:

assertTrue(cloneList == arrList)

Sekarang, mari kita lihat bagaimana melakukan beberapa operasi biasa dalam senarai.

3. Mengambil Item dari Senarai

Kita boleh mendapatkan item dari senarai menggunakan sintaks literal seperti:

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

atau menggunakan kaedah get () dan getAt () :

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

Kita juga boleh mendapatkan item dari senarai menggunakan indeks positif dan negatif. Apabila indeks negatif digunakan, senarai dibaca dari kanan ke kiri:

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

Perhatikan bahawa kaedah get () tidak menyokong indeks negatif.

4. Menambah Item ke dalam Senarai

Terdapat beberapa cara ringkas untuk menambahkan item ke dalam senarai. Mari tentukan senarai kosong dan tambahkan beberapa item padanya:

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

Seterusnya, kita juga dapat menentukan indeks untuk meletakkan item di. Juga, jika panjang senarai kurang daripada indeks yang ditentukan, maka Groovy menambah seberapa banyak nilai nol sebagai perbezaannya :

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

Terakhir, kita dapat menggunakan operator " + =" untuk menambahkan item baru ke dalam senarai. Berbanding dengan pendekatan lain, pengendali ini membuat objek senarai baru dan memberikannya ke senarai pemboleh ubah :

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

5. Mengemas kini Item dalam Senarai

Kita boleh mengemas kini item dalam senarai menggunakan sintaks literal atau kaedah set () :

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

Dalam contoh ini, item pada indeks 1 dan 2 dikemas kini dengan nilai baru.

6. Mengeluarkan Item dari Senarai

Kita boleh membuang item pada indeks tertentu menggunakan kaedah 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 boleh membuang elemen dengan menggunakan kaedah removeElement () . Ini menghilangkan kejadian pertama elemen dari senarai:

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

Selain itu, kita boleh menggunakan operator tolak untuk menghapus semua kejadian elemen dari senarai . Operator ini, bagaimanapun, tidak mengubah senarai yang mendasari - ia mengembalikan senarai baru:

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

7. Pengulangan pada Senarai

Groovy telah menambahkan kaedah baru ke Java Collections API yang ada. Kaedah-kaedah ini mempermudah operasi seperti menyaring, mencari, menyusun, mengagregat dll dengan merangkum kod plat boiler. Mereka juga menyokong pelbagai input termasuk penutupan dan struktur data output.

Mari kita mulakan dengan melihat dua kaedah untuk berulang melalui senarai.

Kaedah masing - masing () menerima penutupan dan sangat mirip dengan kaedah foreach () di Java. Groovy pas parameter tersirat ia yang sepadan dengan elemen semasa dalam setiap lelaran:

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

Kaedah lain, masing-masingWithIndex () memberikan nilai indeks semasa sebagai tambahan kepada elemen semasa:

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

8. Penapisan

Menyaring adalah operasi lain yang sering dilakukan dalam senarai, dan Groovy menyediakan banyak kaedah yang boleh dipilih.

Mari tentukan senarai untuk beroperasi pada:

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

Untuk mencari objek pertama yang sesuai dengan keadaan yang boleh kita gunakan cari :

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

Untuk mencari semua objek yang sesuai dengan keadaan kita boleh menggunakan findAll :

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

Mari lihat contoh lain. Di sini, kami mahukan senarai semua elemen yang berupa nombor:

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

Sebagai alternatif, kita boleh menggunakan kaedah grep untuk melakukan perkara yang sama:

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

Perbezaan antara kaedah grep dan find adalah bahawa grep dapat menerima Objek atau Penutupan sebagai argumen. Oleh itu, ini membolehkan pengurangan penyataan keadaan menjadi minimum:

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

Selain itu, grep menggunakan Object # isCase (java.lang.Object) untuk menilai keadaan pada setiap elemen senarai.

Kadang kala kita hanya berminat dengan item unik dalam senarai . Terdapat dua kaedah yang boleh kita gunakan untuk tujuan ini.

Kaedah unik () secara opsional menerima penutupan dan menyimpan dalam senarai yang mendasari hanya elemen yang sesuai dengan keadaan penutupan sambil membuang yang lain. Ia menggunakan pesanan semula jadi secara lalai untuk menentukan keunikan:

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

Sebagai alternatif, jika syaratnya tidak mengubah senarai yang mendasari, maka kita dapat menggunakan kaedah toUnique () :

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

Sekiranya kita ingin memastikan bahawa beberapa atau semua item dalam senarai memenuhi syarat tertentu, kita boleh menggunakan kaedah setiap () dan apa saja () .

Kaedah setiap () menilai keadaan dalam penutupan terhadap setiap elemen dalam senarai. Kemudian, ia hanya akan menjadi benar jika semua elemen dalam senarai memenuhi syarat:

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

Kaedah any () , sebaliknya, akan benar jika ada unsur dalam senarai yang memenuhi syarat:

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

9. Menyusun

Secara lalai, Groovy menyusun item dalam senarai berdasarkan susunan semula jadi:

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

Tetapi kita juga boleh melewati Perbandingan dengan logik penyortiran tersuai :

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 kaedah min () atau max () untuk mencari nilai maksimum atau minimum tanpa memanggil jenis ():

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. Mengumpul

Kadang-kadang kita mungkin mahu mengubah item dalam senarai dan mengembalikan senarai lain dengan nilai yang dikemas kini. Ini boleh dilakukan menggunakan kaedah collect () :

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

11. Menyertai

Kadang kala, kita mungkin perlu memasukkan item dalam senarai. Untuk melakukan itu, kita boleh menggunakan kaedah join () :

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

12. Kesimpulannya

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

Kami memulakan dengan melihat sintaks literal dan kemudian penggunaannya dalam membuat, mengemas kini, membuang dan mengambil item dalam senarai.

Akhirnya, kami melihat sokongan Groovy untuk melakukan iterasi, menyaring, mencari, mengumpulkan, bergabung dan menyusun senarai.

Seperti biasa semua contoh yang dibincangkan dalam artikel terdapat di GitHub.