Arrays and Lists: create, modify, and access arrays; creating, modifying, and accessing lists

📖 Theory

બે lists, બે નિયમ

FestConnect Mobile પાસે જુદી જરૂરિયાતવાળા બે સંગ્રહ છે. EVENTS ની list, એક વાર load થયા પછી, સત્ર દરમિયાન બદલાવી ન જોઈએ: એ નિશ્ચિત છે. REGISTRATIONS ની list લોકો નોંધણી કરે તેમ વધે છે: એ બદલાવી જ પડે.

Kotlin આને એવા ઇરાદાપૂર્વકના ભેદથી સંભાળે છે જે val સામે var નો પડઘો પાડે છે: કેટલાક સંગ્રહ ફક્ત વાંચી શકાય એવા છે, બીજા બદલી શકાય એવા, અને data બદલાવો જોઈએ કે નહીં એ પ્રમાણે તમે પસંદ કરો છો. આ પાઠ Kotlin ના arrays અને, વધુ મહત્ત્વનું, એની lists આવરે છે, જ્યાં વાંચી શકાય એવી સામે બદલી શકાય એવીની પસંદગી એ નાનો પણ અર્થપૂર્ણ રચનાનો નિર્ણય છે જે ભાષા તમારી પાસે લેવડાવે છે.

📖 Theory

Arrays: નિશ્ચિત માપ

Array નું માપ નિશ્ચિત હોય છે, જે સર્જન વખતે ગોઠવાય છે:

val nums = arrayOf(1, 2, 3) (કે પ્રાથમિક int ના array માટે intArrayOf(1, 2, 3))

Index થી પહોંચો (0 થી ગણાતું): nums[0] એ 1 છે; તમે ઘટક બદલી શકો છો (nums[0] = 5) પણ ઉમેરી કે કાઢી શકતા નથી (લંબાઈ નિશ્ચિત છે). .size ગણતરી આપે છે.

માપ જાણીતું અને નિશ્ચિત હોય ત્યારે arrays કામનાં છે, પણ app ના મોટા ભાગના data માટે (વધતી lists), તમે એને બદલે LISTS તરફ હાથ લંબાવશો, બરાબર જેમ Java માં લવચીક સંગ્રહ માટે તમે arrays કરતાં ArrayList પસંદ કરતા હતા.

📖 Theory

Lists: ફક્ત વાંચી શકાય એવી સામે બદલી શકાય એવી

Kotlin ની lists બે પ્રકારમાં આવે છે, અને પસંદ કરવું એ જ મુખ્ય વિચાર છે:

• listOf(...) એ ફક્ત વાંચી શકાય એવી (immutable) list બનાવે છે: તમે એને વાંચી શકો પણ ઘટકો ઉમેરી, કાઢી, કે બદલી શકતા નથી
• mutableListOf(...) એ બદલી શકાય એવી list બનાવે છે: .add(), .remove(), .removeAt(), અને list[i] = x બધું ચાલે છે

આ val સામે var નો પડઘો પાડે છે: મૂળભૂત રીતે ફક્ત વાંચી શકાય એવી પસંદ કરો (વધુ સલામત, ઇરાદો વધુ સ્પષ્ટ), અને બદલી શકાય એવી ત્યારે જ વાપરો જ્યારે data ખરેખર બદલાતો હોય.

val events = listOf("Garba", "Coding") વધી શકતી નથી; val regs = mutableListOf<String>() વધી શકે છે. બંને 0 થી ગણાતી list[i] ની પહોંચ અને .size વાપરે છે. (Maps અને Sets એ જ વાંચી-શકાય/બદલી-શકાય ની ભાત અનુસરે છે: mapOf/mutableMapOf.)

⌨️ Practical

ફક્ત વાંચી શકાય એવાં events, બદલી શકાય એવી registrations

fun main() {
    // READ-ONLY list: cannot be modified
    val events = listOf("Garba Night", "Coding Contest")
    println(events[0])      // Garba Night   (0-based access)
    println(events.size)    // 2
    // events.add("Webinar")   // COMPILE ERROR: listOf is read-only

    // MUTABLE list: can add/remove/change
    val regs = mutableListOf("Riya")
    regs.add("Aman")        // ok
    regs.add("Zoya")
    regs.removeAt(0)        // removes "Riya"
    println(regs)           // [Aman, Zoya]
    println(regs.size)      // 2
}

🧩 Quiz

તમે listOf("Garba", "Coding") થી list બનાવો છો અને એના પર .add() બોલાવવાનો પ્રયત્ન કરો છો. શું થાય છે?

1. એ વસ્તુ સફળતાપૂર્વક ઉમેરી દે છે
2. COMPILE ની ભૂલ: listOf ફક્ત વાંચી શકાય એવી list બનાવે છે; ઉમેરવું કે કાઢવું હોય તો mutableListOf વાપરો
3. ફક્ત app ચાલે ત્યારે runtime નું તૂટવું
4. એ ચૂપચાપ ઉમેરવાનું અવગણે છે

💭 Think first

ફક્ત વાંચી શકાય એવા સંગ્રહ કેમ પસંદ કરવા?

તમે બધે mutableListOf વાપરીને કયું પસંદ કરવું એની ચિંતા જ ન કરી શકો. તો Kotlin મૂળભૂત રીતે વાંચી શકાય એવી listOf ને કેમ ઉત્તેજન આપે છે? પછી tap કરો.

⚠️ Watch out

Array અને list ના ફાંદા

listOf માં ઉમેરવાનો પ્રયત્ન: એ ફક્ત વાંચી શકાય એવી છે; mutableListOf વાપરો.

Array નું માપ બદલવાનો પ્રયત્ન: arrays નું માપ નિશ્ચિત છે; વધારવા list વાપરો.

મૂળભૂત રીતે બદલી શકાય એવી વાપરવી: data બદલાવો જ પડે એમ ન હોય ત્યાં સુધી listOf (વાંચી શકાય એવી) પસંદ કરો.

Index હદ બહાર: i >= size સાથે list[i] ભૂલ ફેંકે છે; છેલ્લો index એ size માઇનસ 1 છે.

List બદલી શકાય એવી હોય તો val છતાં ફેરફાર ચાલે છે: val નો અર્થ છે કે variable ને ફરી સોંપી શકાતું નથી; val ને સોંપાયેલી mutableListOf હજી બદલી શકાય છે (એની સામગ્રી બદલાય છે, સંદર્ભ નહીં).

📖 Theory

સંગ્રહ તૈયાર; હવે એમના પર ફરો

FestConnect Mobile પોતાનાં events (ફક્ત વાંચી શકાય એવાં) અને registrations (બદલી શકાય એવી) રાખી શકે છે. દરેક વસ્તુ સાથે કંઈક કરવા, એટલે કે એમને છાપવા, ગણવા, ગાળવા, તમને LOOPS જોઈએ. Kotlin ના પાયાનો છેલ્લો પાઠ for અને while ના loops, અને break, continue તથા return ના નિયંત્રણના શબ્દો આવરે છે. પછી Unit 2 આ data અને તર્કને યોગ્ય CLASSES માં ફેરવે છે, અને Kotlin માં FestConnect Mobile ની object આધારિત રચના બાંધે છે.

✅ Summary

Key takeaways

• Arrays નું માપ નિશ્ચિત હોય છે: arrayOf(1,2,3); 0 થી ગણાતા index થી પહોંચો (arr[0]); ઘટકો બદલી શકાય, લંબાઈ નહીં.
• Lists બે પ્રકારમાં આવે છે: listOf(...) ફક્ત વાંચી શકાય એવી (immutable); mutableListOf(...) બદલી શકાય એવી (add/remove/set).
• વાંચી-શકાય સામે બદલી-શકાય નો આ ભેદ val સામે var નો પડઘો પાડે છે; મૂળભૂત રીતે વાંચી શકાય એવી પસંદ કરો.
• ફક્ત વાંચી શકાય એવી lists વાંચવા દે છે (list[i], .size) પણ ફેરફાર નહીં (listOf પર add એ compile ની ભૂલ છે).
• બદલી શકાય એવી lists .add(), .remove(), .removeAt(), અને list[i] = x ને ટેકો આપે છે.
• mutableListOf રાખતા val ની સામગ્રી હજી બદલી શકાય છે (સંદર્ભ નિશ્ચિત છે, list નહીં).
• Memory hook: arrays નું માપ નિશ્ચિત; listOf ફક્ત વાંચી શકાય, mutableListOf બદલી શકાય (val/var ની જેમ).