وقتی اولین بار با کاتلین آشنا شدم، چیزی که منو واقعاً جذب کرد، قدرت و سادگی کار با کالکشن‌ها بود. در این مقاله، می‌خوام شما رو هم با این دنیای جادویی آشنا کنم تا بتونید به راحتی و با لذت از این ابزارهای قدرتمند در پروژه‌هاتون استفاده کنید. بریم سراغش!

مقدمه‌ای بر کالکشن‌ها در کاتلین

کار با داده‌ها در برنامه‌نویسی همیشه یه چالش بزرگ بوده، اما کاتلین با کالکشن‌هاش این چالش رو تبدیل به یه تجربه لذت‌بخش کرده. کالکشن‌ها توی کاتلین ابزارهایی قدرتمند هستن که به ما امکان می‌دن داده‌ها رو به شکلی کارآمد و منظم مدیریت کنیم. این مقاله رو به کالکشن‌ها در کاتلین اختصاص دادم تا با هم ببینیم چرا این ابزارها انقدر مفیدن و چطور می‌تونیم از انواع مختلفشون برای بهبود کدنویسی‌هامون استفاده کنیم.

چرا از کالکشن‌ها استفاده می‌کنیم؟

خب، همه‌مون می‌دونیم که ذخیره و مدیریت داده‌ها در برنامه‌نویسی خیلی مهمه. کالکشن‌ها در کاتلین این امکان رو به ما می‌دن که به‌راحتی مجموعه‌ای از داده‌ها رو ذخیره و مدیریت کنیم. فرض کنید می‌خواید لیستی از نام‌ها، یک مجموعه از اعداد یا یک نقشه از جفت key-value رو ذخیره کنید. با کالکشن‌ها در کاتلین، این کارها خیلی ساده و سریع انجام می‌شه. کالکشن‌ها به ما کمک می‌کنند تا داده‌ها رو به صورت سازمان‌یافته و قابل دسترسی نگهداری کنیم.

انواع کالکشن‌ها در کاتلین

کالکشن‌ها در کاتلین چند نوع اصلی داره: لیست‌ها، مجموعه‌ها (Sets) و نقشه‌ها (Maps). هر کدوم از این‌ها کاربردها و ویژگی‌های خاص خودشون رو دارن. لیست‌ها برای ذخیره‌ی دنباله‌ای از آیتم‌ها استفاده می‌شن که می‌تونن تکراری باشن. مجموعه‌ها برای ذخیره‌ی آیتم‌های یکتا مناسبن و نقشه‌ها برای نگهداری جفت‌های کلید-مقدار (همون  key -value) استفاده می‌شن. به همین دلیل، بسته به نیازمون می‌تونیم از هر کدوم از این کالکشن‌ها استفاده کنیم و برنامه‌نویسی رو به یک تجربه لذت‌بخش تبدیل کنیم.

لیست‌ها در کاتلین

لیست‌ها یکی از مهم‌ترین و پرکاربردترین ساختارهای داده در برنامه‌نویسی هستن و کاتلین هم از این قاعده مستثنا نیست. لیست‌ها به شما این امکان رو می‌دن که مجموعه‌ای از آیتم‌ها رو به ترتیب مشخص ذخیره و مدیریت کنید. این ترتیب می‌تونه برای مقاصد مختلفی مثل مرتب‌سازی، فیلتر کردن و جستجو بسیار مفید باشه.

در کاتلین، لیست‌ها از نوع generic هستن، به این معنی که می‌تونید لیستی از هر نوع داده‌ای بسازید. مثلا می‌تونید لیستی از اعداد صحیح، رشته‌ها یا حتی اشیای پیچیده‌تر داشته باشید.

مثال:

val numberList: List<Int> = listOf(1, 2, 3, 4, 5)
val stringList: List<String> = listOf("Apple", "Banana", "Cherry")

لیست‌ها در کاتلین بر اساس اینترفیس List ساخته می‌شن که تعدادی متد کاربردی برای کار با لیست‌ها داره. برای مثال، می‌تونید از متدهای get, size, contains و خیلی متدهای دیگه استفاده کنید.

ویژگی‌های اصلی لیست‌ها در کاتلین

• ترتیب مشخص: آیتم‌ها در لیست‌ها بر اساس ترتیب اضافه شدن ذخیره می‌شن و این ترتیب حفظ می‌شه.
• دسترسی به ایندکس: می‌تونید با استفاده از ایندکس به آیتم‌های لیست دسترسی پیدا کنید.
• تکرارپذیری: آیتم‌ها می‌تونن تکراری باشن، یعنی می‌تونید چندین بار یک مقدار خاص رو در لیست داشته باشی

لیست‌ها در کاتلین به دو دسته‌ی مهم تغییر پذیر و تغییر ناپذیر تقسیم میشن که در ادامه معرفیشون می‌کنم و فرقشون رو باهم بهتون میگم.

تفاوت بین لیست‌های تغییرناپذیر و تغییرپذیر

حالا که با اصول پایه لیست‌ها در کاتلین آشنا شدیم، بیایید تفاوت بین لیست‌های تغییرناپذیر و تغییرپذیر رو بررسی کنیم.

لیست‌های تغییرناپذیر (Immutable Lists)

لیست‌های تغییرناپذیر بعد از ایجاد قابل تغییر نیستن. یعنی شما نمی‌تونید آیتم‌های جدید به لیست اضافه کنید یا آیتم‌های موجود رو حذف کنید. این نوع لیست‌ها وقتی مفیدن که مطمئن هستید نیازی به تغییر لیست بعد از ایجادش ندارید و می‌خواید از تغییرات ناخواسته جلوگیری کنید.

val immutableList = listOf("Apple", "Banana", "Cherry")
println(immutableList) // Output: [Apple, Banana, Cherry]

منظور از “تغییرات ناخواسته” اینه که وقتی شما یک لیست تغییرناپذیر ایجاد می‌کنید، دیگه نمی‌تونید آیتم‌های اون لیست رو تغییر بدید، حذف کنید یا آیتم جدید بهش اضافه کنید. این ویژگی باعث می‌شه که داده‌های لیست بعد از ایجاد شدن، ثابت بمونن و از تغییرات تصادفی یا غیرمنتظره که ممکنه توسط بخش‌های دیگه کد یا اشخاص دیگه ایجاد بشه، جلوگیری کنه.

برای مثال، فرض کنید شما یه لیست تغییرناپذیر از نام‌های دانش‌آموزان دارید و نمی‌خواید که این لیست در طول اجرای برنامه به هر دلیلی تغییر کنه. با استفاده از لیست تغییرناپذیر، مطمئن می‌شید که هیچ کس نمی‌تونه به طور ناخواسته یا به اشتباه نامی رو به این لیست اضافه کنه یا نامی رو حذف کنه. این کار باعث می‌شه که لیست همیشه در وضعیت اولیه خودش باقی بمونه و داده‌ها بدون تغییر بمونن.

مثال:

val studentNames = listOf("Alice", "Bob", "Charlie")

// حالا اگه بخوایم یه نام جدید به لیست اضافه کنیم:
studentNames.add("David") // Error: Unresolved reference: add

// یا اگه بخوایم یه نام رو حذف کنیم:
studentNames.remove("Alice") // Error: Unresolved reference: remove

با این کار، شما می‌تونید مطمئن باشید که لیست studentNames همیشه همونطوری که تعریف شده باقی می‌مونه و تغییر نمی‌کنه، و این به امنیت و استحکام کدتون کمک زیادی می‌کنه.

لیست‌های تغییرپذیر(Mutable Lists)

حالا لیست‌های تغییرپذیر برعکس قابل تغییر هستن، یعنی می‌تونید آیتم‌های جدید به لیستتون اضافه کنید، آیتم‌های موجود رو تغییر بدید یا حذف کنید. این نوع لیست‌ها وقتی مفیدن که نیاز دارید لیست رو در طول زمان تغییر بدید.

مثالش رو ببینید:

val mutableList = mutableListOf("Apple", "Banana", "Cherry")
mutableList.add("Date")
println(mutableList) // Output: [Apple, Banana, Cherry, Date]

mutableList[1] = "Blueberry"
println(mutableList) // Output: [Apple, Blueberry, Cherry, Date]

mutableList.remove("Cherry")
println(mutableList) // Output: [Apple, Blueberry, Date]

عملیات‌ رایج روی لیست‌ها

توی کالکشن‌ها در کاتلین ، می‌تونیم عملیات‌ مختلفی روی لیست‌ها انجام بدیم که بعضی از رایج‌ترین‌هاش رو با هم بررسی می‌کنیم.

دسترسی به آیتم‌ها با استفاده از ایندکس:

می‌تونیم با استفاده از ایندکس به آیتم‌های لیست دسترسی پیدا کنیم:

val firstFruit = fruits[0]
println(firstFruit) // Output: Apple

پیدا کردن اندازه لیست:

با استفاده از size می‌تونیم اندازه لیست رو بفهمیم:

val numberOfVegetables = vegetables.size
println(numberOfVegetables) // Output: 4

حذف آیتم از لیست تغییرپذیر:

می‌تونیم یه آیتم خاص رو از لیست‌های تغییرپذیر حذف کنیم:

vegetables.remove("Tomato")
println(vegetables) // Output: [Carrot, Potato, Cucumber]

جستجو در لیست:

می‌تونیم با استفاده از contains بررسی کنیم که آیا یه آیتم خاص توی لیست هست یا نه:

val hasBanana = fruits.contains("Banana")
println(hasBanana) // Output: true

مرتب‌سازی لیست:

برای مرتب‌سازی لیست می‌تونیم از متد sorted استفاده کنیم:

val sortedFruits = fruits.sorted()
println(sortedFruits) // Output: [Apple, Banana, Cherry]

حالا که از دست لیست‌ها خلاص شدیم و تقریبا باهاشون آشنا شدیم میتونیم بریم سراغ سِت ها و کار با اونارویاد بگیریم.

مجموعه‌ها (Sets) در کاتلین

اگه تا حالا با زبان‌های دیگه برنامه‌نویسی کار کرده باشین، حتماً با مفهوم مجموعه‌ها آشنا هستین. ولی خب، همیشه یه چیزایی هست که ممکنه ندونیم و می‌خوام در ادامه باهاتون اون‌ها رو به اشتراک بذارم.

مجموعه‌ها (Sets) نوع خاصی از کالکشن‌ها در کاتلین هستن که هیچ عنصر تکراری در اون‌ها وجود نداره. این ویژگی باعث می‌شه که برای ذخیره‌سازی مجموعه‌ای از عناصر یکتا بسیار مناسب باشن.

چرا از مجموعه‌ها استفاده می‌کنیم؟

مجموعه‌ها تو برنامه‌نویسی خیلی کاربرد دارن چون به ما کمک می‌کنن یه سری عناصر رو بدون تکرار و با سرعت بالا ذخیره کنیم. مثلا فرض کنید یه لیست از اعداد دارین و می‌خواین فقط اعداد یکتا رو نگه دارین، مجموعه‌ها بهترین انتخاب هستن. یا مثلاً وقتی می‌خواین چک کنین که یه عنصر خاص تو مجموعه وجود داره یا نه، مجموعه‌ها این کار رو خیلی سریع براتون انجام می‌دن.

تفاوت بین مجموعه‌های تغییرناپذیر و تغییرپذیر

دقیقا مشابه با لیست‌ها، ست‌ها هم دونوع تغییر پذیر و تغیر نا پذیر دارند.:

مجموعه‌های Immutable

مجموعه‌های Immutable در کاتلین، پس از ایجاد شدن، قابل تغییر نیستن. این یعنی نمی‌تونیم بعد از ساختن مجموعه، عناصر جدید بهش اضافه کنیم یا ازش حذف کنیم. بیاید با یه مثال ساده شروع کنیم:

val fruits = setOf("Apple", "Banana", "Cherry", "Apple")
println(fruits)

در اینجا، مجموعه‌ای از میوه‌ها داریم. حتی اگر دو بار “Apple” رو اضافه کنیم، در خروجی فقط یک بار نمایش داده می‌شه چون مجموعه‌ها عنصر تکراری رو قبول نمی‌کنن.

مجموعه‌های Mutable

مجموعه‌های Mutable قابل تغییر هستن، یعنی می‌تونیم بعد از ساختن مجموعه، عناصر جدید بهش اضافه کنیم یا ازش حذف کنیم. بیاید یه مجموعه Mutable بسازیم:

val mutableFruits = mutableSetOf("Apple", "Banana", "Cherry")
mutableFruits.add("Mango")
println(mutableFruits)

در این مثال، ما “Mango” رو به مجموعه اضافه کردیم. چون مجموعه ما Mutable هست، می‌تونیم به راحتی عناصر جدید اضافه کنیم.

همچنین می‌تونیم عناصر رو از مجموعه حذف کنیم:

mutableFruits.remove("Banana")
println(mutableFruits)

در اینجا، “Banana” از مجموعه حذف می‌شه.

عملیات‌ رایج روی مجموعه‌ها

حالا که با انواع مجموعه‌ها آشنا شدیم، بیایید چند تا از عملیات‌ رایج روی مجموعه‌ها رو بررسی کنیم.

بررسی وجود یک عنصر

برای اینکه ببینیم آیا یک عنصر خاص در مجموعه وجود داره یا نه، می‌تونیم از عملگر in استفاده کنیم:

val isAppleInSet = "Apple" in fruits
println(isAppleInSet) // خروجی: true

در این مثال، بررسی می‌کنیم که آیا “Apple” در مجموعه وجود داره یا نه.

اندازه مجموعه

برای اینکه بفهمیم مجموعه چند تا عنصر داره، می‌تونیم از خاصیت size استفاده کنیم:

val sizeOfSet = fruits.size
println(sizeOfSet) // خروجی: ۳

در این مثال، اندازه مجموعه رو که تعداد عناصر یکتاست، به دست میاریم.

پیمایش مجموعه

برای پیمایش عناصر مجموعه، می‌تونیم از حلقه for استفاده کنیم:

for (fruit in fruits) {
    println(fruit)
}

در اینجا هر عنصر از مجموعمون در هر بار اجرای حلقه چاپ میشه.

ترکیب مجموعه‌ها

یکی از قابلیت‌های جالب مجموعه‌ها ترکیب دو مجموعه با هم هست. می‌تونیم با استفاده از عملگر union دو مجموعه رو ترکیب کنیم:

val otherFruits = setOf("Mango", "Pineapple")
val allFruits = fruits.union(otherFruits)
println(allFruits)

در این مثال، دو مجموعه fruits و otherFruits رو با هم ترکیب کردیم.

تفاضل مجموعه‌ها

همچنین می‌تونیم تفاضل دو مجموعه رو بگیریم، یعنی عناصری که در مجموعه اول هستن ولی در مجموعه دوم نیستن:

val difference = fruits.subtract(otherFruits)
println(difference)

در اینجا، عناصری که فقط در مجموعه fruits هستن و در otherFruits نیستن، رو به دست میاریم.

اشتراک مجموعه‌ها

برای پیدا کردن اشتراک دو مجموعه، یعنی عناصری که در هر دو مجموعه وجود دارن، می‌تونیم از عملگر intersect استفاده کنیم:

val commonFruits = fruits.intersect(otherFruits)
println(commonFruits)

در این مثال، عناصری که هم در fruits و هم در otherFruits هستن، به دست میاریم.

نقشه‌ها (Maps) در کاتلین

نقشه‌ها یکی از ساختارهای داده‌ای مهم در کاتلین هستند که بهت اجازه میدن تا داده‌ها رو به صورت زوج‌های کلید و مقدار ذخیره کنی. یعنی به جای اینکه فقط یه لیست از مقادیر داشته باشی، می‌تونی هر مقدار رو به یه کلید اختصاص بدی و بعداً خیلی راحت‌تر بهش دسترسی پیدا کنی.

تفاوت بین نقشه‌های تغییرناپذیر و تغییرپذیر

اول از همه باید بدونی که مثل بقیه مواردگفته شده، توی کاتلین دو نوع نقشه داریم: تغییرناپذیر (Immutable) و تغییرپذیر (Mutable).

نقشه‌های تغییرناپذیر اونایی هستن که بعد از ایجادشون دیگه نمی‌تونی توشون تغییر ایجاد کنی. یعنی اگه یه نقشه تغییرناپذیر ساختی، دیگه نمی‌تونی بهش عنصر جدید اضافه کنی، ازش حذف کنی یا مقدار یه کلید رو تغییر بدی. این نوع نقشه‌ها خیلی به درد زمانی می‌خورن که مطمئنی بعد از ساختن نقشه دیگه نمی‌خوای توش دست ببری. به طور مثال، تنظیمات ثابت یه اپلیکیشن می‌تونه از نقشه‌های تغییرناپذیر استفاده کنه.

نقشه‌های تغییرپذیر اما، برعکس نقشه‌های تغییرناپذیر، می‌تونی توشون تغییر ایجاد کنی. یعنی می‌تونی بهش عنصر اضافه کنی، ازش حذف کنی یا مقادیر کلیدها رو عوض کنی. این نوع نقشه‌ها برای مواقعی که نیاز داری داده‌ها به مرور زمان تغییر کنن، مثل یه لیست از کاربران آنلاین، مناسب هستن.

ایجاد نقشه‌های تغییرناپذیر

برای ایجاد یه نقشه تغییرناپذیر توی کاتلین، می‌تونی از تابع mapOf استفاده کنی. بذار یه مثال بزنم:

val myImmutableMap = mapOf("Ali" to 25, "Sara" to 30, "Reza" to 20)

تو این مثال، یه نقشه تغییرناپذیر ساختیم که سه تا زوج کلید-مقدار داره. کلیدها اسامی افراد هستن و مقادیرشون سن اون افراد.

ایجاد نقشه‌های تغییرپذیر

اگه بخوای یه نقشه تغییرپذیر بسازی، باید از تابع mutableMapOf استفاده کنی. مثال زیر رو ببین:

val myMutableMap = mutableMapOf("Ali" to 25, "Sara" to 30)
myMutableMap["Reza"] = 20  // اضافه کردن یه عنصر جدید
myMutableMap["Sara"] = 31  // تغییر مقدار یه کلید

توی این مثال، اول یه نقشه تغییرپذیر ساختیم و بعدش یه عنصر جدید بهش اضافه کردیم و مقدار یکی از کلیدها رو تغییر دادیم.

عملیات‌ رایج روی نقشه‌ها

حالا که با نحوه ایجاد نقشه‌ها آشنا شدی، بیایم ببینیم چه کارهایی می‌تونی با نقشه‌ها انجام بدی:

1. دسترسی به مقادیر: می‌تونی با استفاده از کلید، به مقدار مربوطه دسترسی پیدا کنی:

   val age = myImmutableMap["Ali"]
   println(age)  // خروجی: 25
   

    

2. بررسی وجود کلید: می‌تونی بررسی کنی که آیا یه کلید خاص توی نقشه وجود داره یا نه:

   if ("Reza" in myImmutableMap) {
       println("Reza is in the map!")
   }
   

    

3. حذف عناصر: توی نقشه‌های تغییرپذیر می‌تونی عناصر رو حذف کنی:

   myMutableMap.remove("Ali")
   println(myMutableMap)  // خروجی: {Sara=31, Reza=20}
   

4. پیمایش نقشه: می‌تونی از یه حلقه for برای پیمایش کلیدها و مقادیر استفاده کنی:

   for ((key, value) in myImmutableMap) {
       println("$key: $value")
   }
   

5. اندازه نقشه: می‌تونی تعداد عناصر نقشه رو بدست بیاری:

   val size = myImmutableMap.size
   println(size)  // خروجی: 3
   

6. پاک‌سازی نقشه: توی نقشه‌های تغییرپذیر می‌تونی کل نقشه رو پاک کنی:

   myMutableMap.clear()
   println(myMutableMap)  // خروجی: {}
   

   حالا که با نقشه‌ها و عملیات‌های رایج روی اون‌ها آشنا شدی، می‌تونی خیلی راحت‌تر از این ساختار داده‌ای قدرتمند توی برنامه‌هات استفاده کنی. چه برای ذخیره داده‌های ثابت و چه برای داده‌هایی که به مرور زمان تغییر می‌کنن، نقشه‌ها یه ابزار فوق‌العاده هستن.

کار با کالکشن‌ها در کاتلین

حالا می‌خوام برات توضیح بدم که چطوری می‌تونی با کالکشن‌ها در کاتلین کار کنی و چطوری اون‌ها رو فیلتر کنی، مرتب‌سازی کنی، گروه‌بندی کنی و حتی عملیات ریاضی روشون انجام بدی.

فیلتر کردن کالکشن‌ها در کاتلین

لیست‌ها:

فرض کن یه لیست از اعداد داری و می‌خوای فقط اعداد زوج رو از توش در بیاری. برای این کار می‌تونی از تابع filter استفاده کنی. بذار یه مثال بزنم:

val numbers = listOf(1, 2, 3, 4, 5, 6)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers)  // خروجی: [2, 4, 6]

این تابع بهت اجازه میده یه شرط تعریف کنی و فقط اون عناصری که شرط رو برآورده می‌کنن نگه داری. مشابه همین رو برای سِت‌ها و مپ‌ها هم داریم مثال های زیر رو ببین:

نقشه‌ها:

فرض کن یه نقشه از اسامی و سن‌ها داری و می‌خوای فقط افرادی که سنشون بالای 25 هست رو فیلتر کنی:

val peopleMap = mapOf("Ali" to 25, "Sara" to 30, "Reza" to 20, "Mina" to 27)
val filteredMap = peopleMap.filter { it.value > 25 }
println(filteredMap)  // خروجی: {Sara=30, Mina=27}

ست‌ها:

برای ست‌ها هم می‌تونی فیلتر انجام بدی. فرض کن یه ست از اعداد داری و می‌خوای فقط اعداد فرد رو نگه داری:

val numberSet = setOf(1, 2, 3, 4, 5)
val oddNumbers = numberSet.filter { it % 2 != 0 }
println(oddNumbers)  // خروجی: [1, 3, 5]

مرتب‌سازی کالکشن‌ها در کاتلین

مرتب‌سازی یه کالکشن هم خیلی آسونه. مثلا اگه یه لیست از اسامی داشته باشی و بخوای اونا رو به ترتیب حروف الفبا مرتب کنی، می‌تونی از تابع sorted استفاده کنی که مثالش رو قبلا زدیم و در اینجا برای نقشه‌‌ها و ست‌ها مثال میزنیم.

نقشه‌ها:

مرتب‌سازی نقشه‌ها کمی متفاوت‌تره. فرض کن می‌خوای نقشه رو بر اساس مقدارها مرتب کنی:

val sortedMap = peopleMap.toList().sortedBy { (_, value) -> value }.toMap()
println(sortedMap)  // خروجی: {Reza=20, Ali=25, Mina=27, Sara=30}

ست‌ها:

ست‌ها به صورت پیش‌فرض مرتب نیستن، اما می‌تونی اونا رو به لیست تبدیل کنی و بعد مرتب کنی:

val sortedSet = numberSet.sorted()
println(sortedSet)  // خروجی: [1, 2, 3, 4, 5]

گروه‌بندی کالکشن‌ها در کاتلین

لیست‌ها:

حالا فرض کن یه لیست از اسامی و سن‌ها داری و می‌خوای افراد رو بر اساس گروه سنی‌شون دسته‌بندی کنی. برای این کار می‌تونی از تابع groupBy استفاده کنی. بذار یه مثال بزنم:

val people = listOf("Ali" to 25, "Sara" to 30, "Reza" to 20, "Mina" to 25)
val groupedByAge = people.groupBy { it.second }
println(groupedByAge)  // خروجی: {25=[(Ali, 25), (Mina, 25)], 30=[(Sara, 30)], 20=[(Reza, 20)]}

این کد افراد رو بر اساس سن‌شون دسته‌بندی می‌کنه و بهت یه نقشه (Map) می‌ده که کلیدها سن‌ها و مقادیرشون لیست افرادیه که اون سن رو دارن.

اینجا داریم یه لیست از زوج‌های کلید-مقدار می‌سازیم. to به ما کمک می‌کنه که هر اسم (به عنوان کلید) رو به سن اون شخص (به عنوان مقدار) متصل کنیم. نتیجه این می‌شه که یه لیست ازPair ها داریم که هر کدوم شامل یه نام و یه سن هستن. به عبارت دیگه، هر عضو از این لیست یه زوج کلید-مقدار هست.

val ali = "Ali" to 25
println(ali)  // خروجی: (Ali, 25)

این کد یه زوج (Pair) می‌سازه که شامل “Ali” به عنوان کلید و 25 به عنوان مقدار هست. به طور مشابه، وقتی که چندین to رو توی یه لیست استفاده می‌کنی، داری یه لیست از pair ها می‌سازی.

نقشه‌ها:
برای گروه‌بندی نقشه‌ها هم، می‌تونی از تابع groupBy استفاده کنی. فرض کن می‌خوای افراد رو بر اساس دسته‌بندی سنی گروه‌بندی کنی:

val groupedByAge = peopleMap.entries.groupBy { it.value / 10 * 10 }
println(groupedByAge)  // خروجی: {20=[Ali=25, Reza=20, Mina=27], 30=[Sara=30]}

ست‌ها:

برای ست‌ها هم می‌تونی از groupBy استفاده کنی. فرض کن می‌خوای اعداد رو بر اساس زوج و فرد بودن گروه‌بندی کنی:

val groupedSet = numberSet.groupBy { it % 2 }
println(groupedSet)  // خروجی: {1=[1, 3, 5], 0=[2, 4]}

انجام عملیات ریاضی روی کالکشن‌ها

اگه بخوای روی کالکشن‌ها در کاتلین عملیات ریاضی انجام بدی، مثلاً مجموع، میانگین یا بزرگترین و کوچکترین مقدار رو پیدا کنی، کاتلین توابع آماده زیادی برات داره. بذار چند تا مثال بزنم:

مجموع مقادیر:

val numbers = listOf(1, 2, 3, 4, 5)
val sum = numbers.sum()
println(sum)  // خروجی: 15

میانگین مقادیر:

val average = numbers.average()
println(average)  // خروجی: 3.0

بزرگترین و کوچکترین مقدار:

val max = numbers.maxOrNull()
val min = numbers.minOrNull()
println("Max: $max, Min: $min")  // خروجی: Max: 5, Min: 1

می‌تونی روی مقادیر نقشه‌ها عملیات ریاضی انجام بدی. مثلا مجموع سن‌ها:

val sumOfAges = peopleMap.values.sum()
println(sumOfAges)  // خروجی: 102

برای ست‌ها هم می‌تونی عملیات مشابهی انجام بدی. مثلا میانگین اعداد:

val average = numberSet.average()
println(average)  // خروجی: 3.0

استفاده از کالکشن‌ها در پروژه‌های واقعی

وقتی با اندروید کار می‌کنی، کالکشن‌ها در خیلی از قسمت‌های پروژه به کار میان. از کار با ویوها و لیست‌ها گرفته تا کار با دیتابیس‌ها و شبکه. اینجا چند مثال عملی‌تر از استفاده از کالکشن‌ها در کاتلیندر پروژه‌های اندروید رو برات میارم.

 مدیریت لیست آیتم‌ها در RecyclerView

ریسایکلر ویو‌ها برای نمایش آیتم ها همیشه نیاز به یک آداپتر دارند که توی اون آداپتر لیستی از آیتم‌ها رو میگیرن و مشص میکنن که هر مولفه از هر آیتم در کجا قرار میگیره مثلا عکس پروفایل بیاد سمت چپ و نام کاربری و توضیحات جلوش نمایش داده بشه. اما برای ارسال دیتای آیتم ها که حالا یا از دیتا بیس گرفته شده یا از سرور، باید از کالکشن‌ها در کاتلین برای انتقالشون (انتقال از جایی که دیتا رو میگیریم به ادپتر) استفاده کنیم. برای آشنایی بیشتر با ریسایکلر ویو و ادپتر‌ها و گرفتن‌ دیتا‌ها از دیتابیس و سرور میتونید به دوره‌جامع اندروید مراجعه کنید که توش تمام این مباحث مفصل توضیح داده شده.

اینجا بخش مرتبط با کالکشن‌ها در کاتلین رو برای مدیریت لیست آیتم‌ها نشون میدم و شما فرض کنید که اطلاعات آیتم‌ها از دیتابیس یا سرور (در اکتیویتی یا فرگمنتمون ) گرفته میشه و توی لیست ذخیره میشه:

val items = listOf(
    Item("Item 1", "Description 1"),
    Item("Item 2", "Description 2"),
    Item("Item 3", "Description 3")
)

// در آداپتر
class ItemAdapter(private var items: List<Item>) : RecyclerView.Adapter<ItemAdapter.ItemViewHolder>() {
    // توابع onCreateViewHolder و onBindViewHolder و غیره

    fun updateItems(newItems: List<Item>) {
        items = newItems
        notifyDataSetChanged()
    }
}

ذخیره و بازیابی داده‌ها با Room

بخش مرتبط با کالکشن‌ها در کاتلین برای ذخیره و بازیابی داده‌ها با استفاده از Room:

@Dao
interface ItemDao {
    @Query("SELECT * FROM item")
    fun getAll(): LiveData<List<Item>>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertAll(items: List<Item>)
}

// در ViewModel
itemViewModel.items.observe(this, Observer { items ->
    adapter.updateItems(items)
})

در اندروید مثال‌های بسیار زیادی میشه برای کاربرد کالکشن‌ها در کاتلین پیدا کرد. توصیه من به شما اینه که حتما برای تمرین خودتون برید داخل سورس‌ کد‌های آماده که به زبان کاتلین هستن، دنبال استفاده از کالکشن‌ها باشید تا راحت تر موضوع واستون جا بیفته.

همچنین توصیه میکنم اگر میخواید بیشتر رو کالکشن‌ها تسلط پیدا کنید یک پروژه کاتلین (نه اندروید مثلا توی intellij idea) ایجاد کنید و سعی کنید با کالکشن‌ها در کاتلین بازی کنید و خروجی‌هاشون رو توی کنسول مشاهده کنید. حتی میتونید ارد سایت هایی مثل:

Kotlin Koans،  Exercism، HackerRank  بشید و از تمریناتی که دادن برای بالا بردن مهارتتون استفاده کنید.