Scribd
Upload
6 views7 pages

1 - Intro

1- Intro

Uploaded by

specsdeveloper13
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
6 views7 pages

1 - Intro

1- Intro

Uploaded by

specsdeveloper13
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 7

Trending Now Data Structures Algorithms Topic-wise Practice Python Machine Learning Data Science J

Kotlin Collections
Read Discuss Courses Practice

In Kotlin, collections are used to store and manipulate groups of objects or


data. There are several types of collections available in Kotlin, including:

1. Lists – Ordered collections of elements that allow duplicates.


2. Sets – Unordered collections of unique elements.
3. Maps – Collections of key-value pairs, where each key is unique.
4. Arrays – Fixed-size collections of elements with a specific type.
5. Sequences – Lazily evaluated collections of elements that can be processed
in a pipeline.

Here’s an example of creating and using a list in Kotlin:

Kotlin

val fruits = listOf("apple", "banana", "orange", "grape")

// Access elements in the list


println("First fruit: ${fruits[0]}")
println("Last fruit: ${fruits.last()}")

// Iterate over the list


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

// Filter the list


val filtered = fruits.filter { it.startsWith("a") }
println("Filtered list: $filtered")

In this example, we create a list of fruits using the listOf function, which takes a
variable number of elements and returns an immutable list. We then
demonstrate how to access elements in the list using indexing and the last
function, and how to iterate over the list using a for loop. Finally, we use the
filter function to create a new list containing only the elements that start with
the letter “a”.

Kotlin’s other collection types can be used in similar ways, with specific
functions and methods tailored to each type’s unique characteristics. By using
these collection types, you can easily manage groups of data in your Kotlin
programs.

Get Paid with SRF coins fo


browsing and searching th
web, spend coins to buy ra
NFTs

Surfcoin Open

Similar to Java Collections, Kotlin also introduced the concept of collections. A


collection usually contains a number of objects of the same type and these
objects in the collection are called elements or items. Kotlin Standard Library
provides a rich set of tools for managing collections.

Types of Collections
In Kotlin collections are categorized into two forms.

1. Immutable Collection
2. Mutable Collection

1. Immutable Collection

It means that it supports only read-only functionalities and can not be modified
its elements. Immutable Collections and their corresponding methods are:

List – listOf() and listOf<T>()


Set – setOf()
Map – mapOf()

List – It is an ordered collection in which we can access elements or items by


using indices – integer numbers that define a position for each element.
Elements can be repeated in a list any number of times. We can not perform
add or remove operations in the immutable list.

Kotlin program to demonstrate the immutable list:

Kotlin

// An example for immutable list


fun main(args: Array<String>) {
val immutableList = listOf("Mahipal","Nikhil","Rahul")
// gives compile time error
// immutableList.add = "Praveen"
for(item in immutableList){
println(item)
}
}

Output:

Mahipal
Nikhil
Rahul

Set – It is a collection of unordered elements also it does not support duplicate


elements. It is a collection of unique elements. Generally, the order of set
elements does not have a significant effect. We can not perform add or remove
operations because it is an immutable Set.

Kotlin program to demonstrate the immutable set:

Kotlin

fun main(args: Array<String>) {


// initialize with duplicate values
// but output with no repetition
var immutableSet = setOf(6,9,9,0,0,"Mahipal","Nikhil")
// gives compile time error
// immutableSet.add(7)
for(item in immutableSet){
println(item)
}
}

Output:

6
9
0
Mahipal
Nikhil

Map – Map keys are unique and hold only one value for each key, it is a set of
key-value pairs. Each key maps to exactly one value. The values can be
duplicates but keys should be unique. Maps are used to store logical
connections between two objects, for example, a student ID and their name. As
it is immutable its size is fixed and its methods support read-only access.

Kotlin program to demonstrate the immutable map:

Java

// An example for immutable map


fun main(args : Array<String>) {
var immutableMap = mapOf(9 to "Mahipal",8 to "Nikhil",7 to "Rahul")
// gives compile time error
// immutableMap.put(9,"Praveen")
for(key in immutableMap.keys){
println(immutableMap[key])
}
}

Output:

Mahipal
Nikhil
Rahul
2. Mutable Collection

It supports both read and write functionalities. Mutable collections and their
corresponding methods are:

List – mutableListOf(),arrayListOf() and ArrayList


Set – mutableSetOf(), hashSetOf()
Map – mutableMapOf(), hashMapOf() and HashMap

List – Since mutable list supports read and write operation, declared elements
in the list can either be removed or added.

Kotlin program to demonstrate the mutable list:

Kotlin

fun main(args : Array<String>) {


var mutableList = mutableListOf("Mahipal","Nikhil","Rahul")
// we can modify the element
mutableList[0] = "Praveen"
// add one more element in the list
mutableList.add("Abhi")
for(item in mutableList){
println(item)
}
}

Output:

Praveen
Nikhil
Rahul
Abhi

Set – The mutable Set supports both read and write functionality. We can
access add or remove elements from the collections easily and it will preserve
the order of the elements.

Kotlin program to demonstrate the mutable set:


Kotlin

fun main(args: Array<String>) {


var mutableSet = mutableSetOf<Int>(6,10)
// adding elements in set
mutableSet.add(2)
mutableSet.add(5)
for(item in mutableSet){
println(item)
}
}

Output:

6
10
2
5

Map – It is mutable so it supports functionalities like put, remove, clear, etc.

Kotlin program to demonstrate the mutable map.

Kotlin

fun main(args : Array<String>) {


var mutableMap = mutableMapOf<Int,String>(1 to "Mahipal",2 to "Nikhil",3 to "
// we can modify the element
mutableMap.put(1,"Praveen")
// add one more element in the list
mutableMap.put(4,"Abhi")
for(item in mutableMap.values){
println(item)
}
}

Output:

Praveen
Nikhil
Rahul
Abhi

Here are some advantages and disadvantages of using collections in Kotlin:

Advantages:

1. Improved code readability: Collections can make your code more readable
and expressive by providing a higher-level abstraction for working with
data.
2. Better memory management: By using collections, you can avoid manual
memory management and allow the Kotlin runtime to manage the memory
for you.
3. Increased efficiency: Kotlin’s collection types are designed for efficient
storage and retrieval of data, making them ideal for large datasets or
computationally intensive operations.
4. Increased type safety: Collections provide type safety by ensuring that only
elements of the correct type can be added to a collection.

Disadvantages:

1. Performance overhead: Collections can add some performance overhead


compared to working directly with primitive data types or arrays.
Memory usage: Depending on the size and complexity of your collections,
they can use more memory than other data structures.
2. Complexity: Collections can add complexity to your code, particularly if you
need to perform complex operations on the data.
Overall, collections are a powerful tool for working with data in Kotlin, but
they should be used judiciously based on the specific needs of your
3. program. In general, collections are ideal for situations where you need to
manage large or complex datasets, or when you need to perform
sophisticated operations on the data.

Last Updated : 14 Mar, 2023 20

Similar Reads

You might also like