Shared Flow

• shares emitted value to all collectors in a broadcast way

• all collectors receives all emitted values

• This flow is active regardless of active collectors

You can customize the SharedFlow behavior in the following ways:

• replay lets you resend a number of previously-emitted values for new subscribers.

• onBufferOverflow lets you specify a policy for when the buffer is full of items to be sent. The default value is BufferOverflow.SUSPEND, which makes the caller suspend. Other options are DROP_LATEST or DROP_OLDEST.

Code gist can be found in https://gist.github.com/vprabhu/adf153e7f3cbe6f5c39a4efe2c5d3400

State Flows

• emits a single updated value to its collectors

• current value can be accessed using value property

update{...}

• thread safe function to change the state

• excepts a block of code and this code block result is updated to value property which turns to be the updated value and this valueis emitted to all collectors

Code gist can be found in https://gist.github.com/vprabhu/3473f8c69375ba6271b57d426fcfacfd

Please leave your comments to improve and discuss more

Happy and Enjoy coding

Cold Flow

• Flows created with flow builders are cold by default

Properties

• Becomes active on terminal operators(like collect , first, last ....)

• Becomes inactive when cancelling the collecting coroutine

• They emit individual emissions to every collector

• Emission and Collection are happening in same coroutines

suspend fun main(): Unit = coroutineScope {

    launch {
        println("Collector 1 in ${Thread.currentThread().name}")
        simpleFlow().collect { value ->
            println("Collecting from Collector 1 -> $value")
        }
    }

    launch {
        println("Collector 2 in ${Thread.currentThread().name}")
        simpleFlow().collect { value ->
            println("Collecting from Collector 2 -> $value")
        }
    }
}


private fun simpleFlow() = flow {
    println("Emission in ${Thread.currentThread().name}")
    repeat(3){
        kotlinx.coroutines.delay(250)
        println("Emitting $it")
        emit(it)
    }
}

/**
 * output
 * Collector 1 in DefaultDispatcher-worker-2
 * Collector 2 in DefaultDispatcher-worker-1
 * Emission in DefaultDispatcher-worker-2
 * Emission in DefaultDispatcher-worker-1
 * Emitting 0
 * Emitting 0
 * Collecting from Collector 1 -> 0
 * Collecting from Collector 2 -> 0
 * Emitting 1
 * Emitting 1
 * Collecting from Collector 2 -> 1
 * Collecting from Collector 1 -> 1
 * Emitting 2
 * Emitting 2
 * Collecting from Collector 2 -> 2
 * Collecting from Collector 1 -> 2
 */

In above code , we can observe the following

• Emissions and collectors are running in same coroutine

• Individual Emissions for every collectors

Code can be found inhttps://gist.github.com/vprabhu/69d912d7dfb8751badd26dff1d8eba1a

Hot Flow

• are active regardless of existence of collectors

Properties

• values that got emitted after we start collecting are the ones we will collect , it is possible to lose some emissions

• stays active even when is no collectors

• Emissions and collections are happening in different coroutines

Types of Hot Flow

1.Shared Flow

2.State Flow

suspend fun main(): Unit = coroutineScope {

    val sharedFlow = MutableSharedFlow<Int>()

    launch {
        println("Emitting in ${Thread.currentThread().name}")
        repeat(3) {
            kotlinx.coroutines.delay(250)
            println("Emitting $it")
            sharedFlow.emit(it)
        }
    }

    launch {
        println("Collector 1 in ${Thread.currentThread().name}")
        delay(550)
        sharedFlow.collect { value ->
            println("Collecting from Collector 1 -> $value")
        }
    }

    launch {
        println("Collector 2 in ${Thread.currentThread().name}")
        sharedFlow.collect { value ->
            println("Collecting from Collector 2 -> $value")
        }
    }
}

/**
 * output :
 * Emitting in DefaultDispatcher-worker-2
 * Collector 1 in DefaultDispatcher-worker-1
 * Collector 2 in DefaultDispatcher-worker-3
 * Emitting 0
 * Collecting from Collector 2 -> 0
 * Emitting 1
 * Collecting from Collector 2 -> 1
 * Emitting 2
 * Collecting from Collector 1 -> 2
 * Collecting from Collector 2 -> 2
 *
 *
 */

In above code , we can observe the following

• Emission and Collectors are happening in different coroutines

• we can see in output where Collector 2 is the only one which collects all emissions and Collector 1 has missed emissions

Code can be found in https://gist.github.com/vprabhu/30f210ce4f9e8a3b89b2b92416e53493

In the next article , we will discuss about State Flow and Shared Flow.

Please leave your comments to improve and discuss more

Happy and Enjoy coding

There are 2 ways to cancel the flow

1.Cancel the coroutine job

    // cancel the job
    val job = launch {
        sampleFlow()
            .onCompletion { cause ->
                if (cause is CancellationException) {
                    println("Flow cancelled Manually by job ")
                }
            }
            .collect {
                println("Type 1 Received $it")
            }
    }

    delay(550)
    job.cancel()
/**
     * Output :
     * Type 1 Received 1
     * Type 1 Received 3
     * Flow cancelled Manually by job
     */

2.Cancel in scope

// cancel the code in scope
launch {
    sampleFlow()
        .onCompletion { cause ->
            if (cause is CancellationException) {
                println("Flow cancelled Manually in scope")
            }
        }.collect {
            println("Type 2 Received $it")
            if (it == 3) {
                cancel()
            }
        }
}.join()
/**
     * Output :
     * Type 2 Received 1
     * Type 2 Received 3
     * Flow cancelled Manually in scope
     */

Code gist for 2 types of cancelling can be found in https://gist.github.com/vprabhu/ebce4cf922f50325f3f82b400681c0ac

Cooperative Cancellation

• All suspend function in coroutines are cancellable

• They check for coroutine cancellation internally and throw CancellationException when cancelled

• But if a coroutine is not checking for cancellation when working on its job , then it is non-cancellable .

Behaviour of flowOf() when cancelling

flowOf() doesn't check internally if the coroutine is active

•         launch {
              flowOf(1,3,5)
                  .onCompletion { cause ->
                      if (cause is CancellationException) {
                          println("Flow cancelled $cause")
                      }
                  }
                  .collect {
                      println("Received $it")
                      if (it == 3) {
                          cancel()
                      }
                  }
          }.join()
  
          /**
           * output :
           * Received 1
           * Received 3
           * Received 5
           */
  

  In the above code , even when you are cancelling the flow if the value is 3 inside the collect{} block , its not stopping the flow.

  There are 2 ways to check that

1.ensureActive() in onEach() block

 launch {
        flowOf(1,3,5)
            .onCompletion { cause ->
                if (cause is CancellationException) {
                    println("Flow cancelled $cause")
                }
            }.onEach {
                ensureActive()
            }
            .collect {
                println("Received $it")
                if (it == 3) {
                    cancel()
                }
            }
    }.join()

    /**
     * output : 
     * Received 1
     * Received 3
     * Flow cancelled kotlinx.coroutines.JobCancellationException:
     *   StandaloneCoroutine was cancelled; job=StandaloneCoroutine{Cancelling}@635a732e
     */

2.cancellable()

 launch {
        flowOf(1,3,5)
            .onCompletion { cause ->
                if (cause is CancellationException) {
                    println("Flow cancelled $cause")
                }
            }
            .cancellable()
            .collect {
                println("Received $it")
                if (it == 3) {
                    cancel()
                }
            }
    }.join()

    /**
     * output :
     * Received 1
     * Received 3
     * Flow cancelled kotlinx.coroutines.JobCancellationException:
     *   StandaloneCoroutine was cancelled; job=StandaloneCoroutine{Cancelling}@635a732e
     */

Code gist for 2 types of cancelling in the flowOf() can be found in https://gist.github.com/vprabhu/1a9defc5e8decffc619b5ed746b43d17

When the flow is working on something intensive , we can use ensureActive() inside the function to cancel it. Let me know if you need a sample code .

In the next article , we will discuss about Cold Flow and Hot Flow.

Please leave your comments to improve and discuss more

Happy and Enjoy coding

Code : https://gist.github.com/vprabhu/04cd8f6eaeecaf0d3de72049d023eddf

Sample Android App :

Code : https://github.com/vprabhu/FlowUpdateUI/

This simple android app demos how to update compose UI ( Progress bar and result text) with the help of flow operators .

What is Intermediate Operators?

• These operators can transform the flow

• These operators are applied to upstream flow and return a downstream flow

• These operators are not suspending function means it executes instantly and return a new transformed flow.

In this article ,we will learn about most used operators in Android app development.

onStart()

Syntax:

fun <T> Flow<T>.onStart(action: suspend FlowCollector<T>.() -> Unit): Flow<T>(source)

As we can see from above syntax ,

The action block is executed before the collection of flow and this is called before the upstream starts

onEach()

Syntax:

fun <T> Flow<T>.onEach(action: suspend (T) -> Unit): Flow<T>(source)

• As the name implies , this operator is executed on emission of each value

• returns a flow after executing the action on each value/item from the upstream flow to downstream flow

onCompleted()

Syntax:

fun <T> Flow<T>.onCompletion(action: suspend FlowCollector<T>.(cause: Throwable?) -> Unit): Flow<T>(source)

• As the name implies , this operator is executed after the flow is completed or cancelled.

• cause:Throwable -> this return null when the flow is completed and the same will return exception if the flow is cancelled .

In the next article , we will discuss about Flow Cancellation.

Please leave your comments to improve and discuss more

Happy and Enjoy coding

try/catch operator

• We can simply enclose the collect block with try/catch as follows

suspend fun main(): Unit = coroutineScope {

    launch {
        val brandFlow = brandFlow()
        try {
            brandFlow.collect { name ->
                println(name)
            }
        } catch (ex: Exception) {
            println("Caught Exception $ex")
        }
    }
}


private fun brandFlow() = flow {
    emit("Google Pixel")
    emit("Samsung")
    emit("Apple")

    throw Exception("Anonymous Exception")
}

What happens if an exception is thrown in collect block , one option is to use try/catch block which might make the code more complex .

Call to emit() internally leads to the execution of collect block (Flows under the hood)

OnEach()

• Returns a flow that invokes the given action before each value of the upstream flow is emitted downstream.

• Adding this operator before catch{...} block ensures that all the exception are caught and the collect{...} will be empty as we see in the below code

Exception Transparency

1.A Downstream exception must always be propagated to collector

2.Once an uncaught exception is thrown downstream , the flow isn't allowed to emit additional values

use catch operator instead of try/catch block

catch()

• only catches upstream exception and passes all downstream exceptions

• use this operator to follow the exception transparency principle .

• When flow builder throws exception , the applied operators will be stopped

suspend fun main(): Unit = coroutineScope {

    launch {
        val brandFlow = brandFlow()
        brandFlow
            .onEach { name ->
                println(name)
            }
            .catch { cause ->
                println("Caught Exception : $cause")
            }
            .collect{}
    }
}


private fun brandFlow() = flow {
    emit("Google Pixel")
    emit("Samsung")
    throw Exception("Anonymous Exception")
    emit("Apple")
}

Please run and play with above Kotlin codes to understand it in a better way .Just copy and paste it in a kotlin file .

In the next article , we will discuss about Flow intermediate operators .

Please leave your comments to improve and discuss more

Happy and Enjoy coding

Code gist can be found in https://gist.github.com/vprabhu/20bf26e73451ae9ea0876e3780537d4a

Whats is Terminal Operators?

• Its a suspend function

• Starts the flow's collection

Terminal Operators List

There are some terminal operators which we can used to start the collection of the flow

Collect()

• collects the given flow

• commonly used with onEach() , onCompletion() and catch to collect all emitted values

    val flow = flow {
        delay(200)
        emit(1)
  
        delay(200)
        emit(2)
  
        delay(200)
        emit(2)
    }
  
      flow.collect { receivedValue ->
                println("Collect Received value 1: $receivedValue")
                /** Output :
                 * Collect Received value 1: 1
                 * Collect Received value 1: 2
                 * Collect Received value 1: 2
                 */
      }
  

first() and last()

• first() returns the first element emitted by flow and cancels the flow's cancellation.

• last() returns the last element emitted by the flow.

val itemFirst = flow.first()
println("first() flow : $itemFirst")
/** Output :
 * first() flow : 1
 */

val itemLast = flow.last()
println("last() flow : $itemLast")
/**
 * last() flow : 2
 */

single()

• Collects the only and one value from flow

• If flow emits multiple values , it throws the following error

Exception in thread "main" java.lang.IllegalArgumentException: Flow has more than one element

val singleFlow = flow {
        emit("Single Emitted value")
    }

val itemSingle = singleFlow.single()
println("single() flow : $itemSingle") 
/**
*  output : single() flow : Single Emitted value
*/

toSet()

• converts the flow output to set

val setFLow = flow.toSet()
println("toSet() flow : $setFLow")
/**
 * Output :  toSet() flow : [1, 2]
 */

toList()

• converts the flow to list

val listFLow = flow.toList()
println("toList() flow : $listFLow")
/**
 * toList() flow : [1, 2, 2]
 */

In the next article , we will discuss about Exception Handling in Flow.

Please leave your comments to improve.

Happy and Enjoy coding

LifeCycle is a class from androidx.lifecycle package which helps us to get the information and observe on the lifecycle state of components like Activities and fragments

Two things to consider

1.State : Created,Started,Resumed,Destroyed and Initialized

2.Event : ON_CREATE , ON_START, ON_RESUME,ON_PAUSE, ON_STOP and ON_DESTROY

As the legend diagram follows to explain the same

In Activities and fragments , there are methods expose from Activity() and Fragment() class to observe these lifecycle events to meet our requirements in UI. But in compose , there are no such methods to observe the lifecycle states and events which is in built with composable . In the following ways we can get to know the lifecycle state and events.

LifeCycle Library

androidx.lifecycle - includes APIs to observe and know the lifecycle state.

Get Lifecycle State with Flows

• Property from lifecycle which provides Lifecycle.State as a kotlin state flow

• collect this flow as state

• we can read these states during UI composition

There are 2 ways to do this

1.currentStateFlow

• this is from lifecycle-common module

 val stateFlow = LocalLifecycleOwner.current.lifecycle.currentStateFlow
 val currentLifecycleState by stateFlow.collectAsState()

 Log.d("LifecycleScreen", "Lifecycle state: ${currentLifecycleState.name}")
     /*
     *  When launched ->
     *                  LifecycleScreen: RESUMED
     *  When Back button tapped ->
     *                  Lifecycle state: STARTED
     *  When Home button tapped ->
     *                  Lifecycle state: STARTED
     *                  Lifecycle state: CREATED
     * When recent button tapped ->
     *                  Lifecycle state: STARTED
     *                  Lifecycle state: CREATED
     *
     */

2.currentStateAsState

• lifecycle-runtime-compose - provides easy way to read current lifecycle state .

val currentLifecycleState = LocalLifecycleOwner.current.lifecycle
                 .currentStateAsState()
Log.d("LifecycleScreen", "Lifecycle state: ${currentLifecycleState.value}")
    /*
     *  When launched ->
     *                  LifecycleScreen: RESUMED
     *  When Back button tapped ->
     *                  Lifecycle state: STARTED
     *  When Home button tapped ->
     *                  Lifecycle state: STARTED
     *                  Lifecycle state: CREATED
     * When recent button tapped ->
     *                  Lifecycle state: STARTED
     *                  Lifecycle state: CREATED
     *
     */

LifecycleEventEffect

• allows us to run a block of code when certain Lifecycle.Event occurs

@Composable
fun LifecycleScreen() {

    val textValue = remember { mutableStateOf("") }

    Text(
        textValue.value,
        fontSize = 32.sp,
        modifier = Modifier.padding(32.dp)
    )

    LifecycleEventEffect(Lifecycle.Event.ON_CREATE) {
        Log.d("LifecycleScreen", "LifecycleScreen: The current state is ON_CREATE")
    }

    LifecycleEventEffect(Lifecycle.Event.ON_START) {
        Log.d("LifecycleScreen", "LifecycleScreen: The current state is ON_START")
    }

    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
        Log.d("LifecycleScreen", "LifecycleScreen: The current state is ON_RESUME")
        textValue.value = "ON_RESUME"
    }

    LifecycleEventEffect(Lifecycle.Event.ON_PAUSE) {
        Log.d("LifecycleScreen", "LifecycleScreen: The current state is ON_PAUSE")
        textValue.value = "ON_PAUSE"
    }

    LifecycleEventEffect(Lifecycle.Event.ON_STOP) {
        Log.d("LifecycleScreen", "LifecycleScreen: The current state is ON_STOP")
    }

}

The logs are as follows

1.when the above compose is launched for first time ,

LifecycleScreen D LifecycleScreen: The current state is ON_CREATE

LifecycleScreen D LifecycleScreen: The current state is ON_START

LifecycleScreen D LifecycleScreen: The current state is ON_RESUME

2.When back button is pressed

LifecycleScreen D LifecycleScreen: The current state is ON_PAUSE

LifecycleScreen D LifecycleScreen: The current state is ON_STOP

3.When Home button is pressed

LifecycleScreen D LifecycleScreen: The current state is ON_PAUSE

LifecycleScreen D LifecycleScreen: The current state is ON_STOP

4.When Recent button is pressed

LifecycleScreen D LifecycleScreen: The current state is ON_PAUSE

LifecycleScreen D LifecycleScreen: The current state is ON_STOP

Whwn you add the following code and run the app

  LifecycleEventEffect(Lifecycle.Event.ON_DESTROY) {
        Log.d(
            "LifecycleScreen",
            "LifecycleScreen: The current state is ON_DESTROY"
        )
    }

we will get this crash report

java.lang.IllegalArgumentException: LifecycleEventEffect cannot be used to listen for Lifecycle.Event.ON_DESTROY, since Compose disposes of the composition before ON_DESTROY observers are invoked.

LifecycleStartEffect&LifecycleResumeEffect

• similar to LifecycleEventEffect but it runs only on ON_Start and ON_Resume Event

• It takes key that behaves like any other compose keys i.e when key changes , it triggers the code block to run again

• when the ON_Stop event triggered , it execute the onStopOrDispose block which helps us to clean up / free resource when this lifecycle event is triggered

• when the ON_Pause event triggered , it execute the onPauseOrDispose block

@Composable
fun LifecycleScreen() {

    LifecycleStartEffect() {
        Log.d(
            "LifecycleScreen",
            "LifecycleScreen: LifecycleStartEffect"
        )
        onStopOrDispose {
            Log.d(
                "LifecycleScreen",
                "LifecycleScreen: onStopOrDispose"
            )
        }
    }

    LifecycleResumeEffect() {
        Log.d(
            "LifecycleScreen",
            "LifecycleScreen: LifecycleResumeEffect"
        )
        onPauseOrDispose {
            Log.d(
                "LifecycleScreen",
                "LifecycleScreen: onPauseOrDispose"
            )
        }
    }
}

The Logs are as folows

1.When App launched for first time

LifecycleScreen D LifecycleScreen: LifecycleStartEffect

LifecycleScreen D LifecycleScreen: LifecycleResumeEffect

2.When Home Button is tapped

LifecycleScreen D LifecycleScreen: onPauseOrDispose

LifecycleScreen D LifecycleScreen: onStopOrDispose

3.When Recent button is tapped

LifecycleScreen D LifecycleScreen: onPauseOrDispose

LifecycleScreen D LifecycleScreen: onStopOrDispose

4.When back button is tapped

LifecycleScreen D LifecycleScreen: onPauseOrDispose

LifecycleScreen D LifecycleScreen: onStopOrDispose

LifecycleScreen D LifecycleScreen: onPauseOrDispose

LifecycleScreen D LifecycleScreen: onStopOrDispose

As you can observe in the above log , when back button is pressed , the onPauseOrDispose and onStopOrDispose are executed twice(i think its a bug) in case of LifecycleStartEffect and LifecycleResumeEffect but this is not the case when we use LifecycleEventEffect

Please run the code once in each code block to get better understanding of this lifecycle events and states in compose .

Please leave your comments to improve.

Happy and Enjoy coding

Code gist can be found in https://gist.github.com/vprabhu/cf5f6407516f0bc97d764c7a9961e3cd

Whats is Flow ?

Already we know that suspend function asynchronously returns a single value .

Flows can return multiple asynchronously computed values

Flow Builders

we can build a flow using one of the following ways

1. <T> flowOf(value : T)

Creates a flow from fixed set of any values which is it can emit both a single type value and multiple data type values as follows

/**
 * flowOf() -> Create a flow from fixed set of values
 */
val singleValueFlow = flowOf<Int>(578943).collect { value ->
    println("Emitted Value : $value") // output : 578943
}

/*
 * flowOf() -> creating a flow with multiple data types
 */
val multiValueFlows = flowOf<Any>(23, 2.90, false, "Android 1.0", 09.2008)

multiValueFlows.collect { value ->
    println("multiValueFlows ->  Emitted Value : $value")
    //output :
    //multiValueFlows ->  Emitted Value : 23
    //multiValueFlows ->  Emitted Value : 2.9
    //multiValueFlows ->  Emitted Value : false
    //multiValueFlows ->  Emitted Value : Android 1.0
    //multiValueFlows ->  Emitted Value : 9.2008
}

2.<T> Iterable<T>.asFlow()

Extension function for various types of iterators to convert them into flows and it cal also emit multiple data type values

/**
 * asFlow() -> extension function on various types to convert them into Flows
 */
listOf("A", "B", "C", 4, true, 90.89).asFlow().collect { value ->
    println("AsFlow Emitted Value : $value")
    //output :
    //AsFlow Emitted Value : A
    //AsFlow Emitted Value : B
    //AsFlow Emitted Value : C
    //AsFlow Emitted Value : 4
    //AsFlow Emitted Value : true
    //AsFlow Emitted Value : 90.89
}

3.<T> flow(block: suspend <T>.() -> Unit)

Creates a flow from suspendable code block given

/**
 * flow {..} -> creates a flow from the suspendable block given
 */
flow {
    kotlinx.coroutines.delay(2000)
    emit(890)
    emit(returnSomething())
}.collect { value ->
    println("flow {} Emitted Value : $value")
    // output :
    // flow {} Emitted Value : 890
    // flow {} Emitted Value : 340
}

fun returnSomething(): Int {
    return 340
}

Important Considerations:

Simply put

collect{ .. } -> Terminal flow operator that collects the given flow

emit() -> Collects the value emitted by the upstream.

we will discuss this is further articles

Please leave your comments to improve.

Happy and Enjoy coding

Lets understand why we need BOM , then we will discuss what is BOM

Why BOM?

• Compose libraries are version independently that is version number are maintained different for each library .

• For developer , it is difficult to find the latest stable version for each library and add it in dependencies(module level gradle)

  Don't worry BOM is there to save us from this mess

What is BOM?

• Bill of Materials lets you manage all of our compose library versions by mentioning only the BOM version

• BOM has link to all the stable version of different compose libraries to work well together

• When we add BOM in our app , we don't have to mention version for any compose library

• BOM just ensures that different compose library versions are compatible and it doesn't add any compose library in our app

• When we update BOM version , all the compose library version mentioned in gradle are automatically updated to their newer/latest version

BOM Usage

    // add BOM
    implementation(platform("androidx.compose:compose-bom:2024.02.01"))
    // add compose library without version number
    implementation("androidx.compose.ui:ui")
    implementation("androidx.compose.ui:ui-graphics")
    implementation("androidx.compose.ui:ui-tooling-preview")
    // add a specific version which overrides BOM 
    implementation("androidx.compose.material3:material3:1.2.1")

As we seen in above code , we can observe the following

1. How to add compose-bom with version number

2. How to add compose library without version number

3. How to override desired compose library with our version

BOM supported compose libraries

The following compose libraries and its group is linked to BOM

• compose.animation

• compose.foundation

• compose.material

• compose.runtime

• compose.ui

  💡

  Kotlin complier externsion(androidx.compose.compiler) is not linked to BOM , as to make sure we use a version that is compatible to Kotlin version used in our app.

So finally, lets use the Compose - Bill of Materials(recommended not forced to use) and reduce our time to implement the latest versions of compose that work well together .

Please leave your comments to improve.

Happy and Enjoy coding

Foundation

• List is an ordered collection which means every item in has its position that you are referring

• Set is an unordered collection which stores element in certain order based on set implementation which can be LinkedHasSet , SortedSet , etc . So results are predictable based on the set implementation used

Position

elementAt()

• retrieving item at specific position in given collection

• called with Int argument

• returns the collection item at given position

useful for collections that don't provide indexed access

In case of List , it has indexed access operator get() / []

first() - returns first collection item

last() - returns last collection item

elementAtOrNull() - returns null when the given parameter position is out of bounds for collection

elementAtOrElse()

• takes lambda function that maps Int argument

• returns one of the following

  1.returns elementAt() if the position passed is valid

  2.returns lambda function result if position is out of bounds

    val names = linkedSetOf("Sam", "Dev", "David", "Katherine", "Anne", "Chris")
    println(names.elementAt(1))
    // output : Dev

    println(names.first())
    // output : Sam
    println(names.last())
    // output : Chris

    println(names.elementAtOrNull(7))
    // output : null

    val result = names.elementAtOrElse(4) { index ->
        "The value at $index is invalid"
    }
    println(result)
    // output : Anne

Condition

first() with predicate - returns the first item matching the predicate in given collection

last() with predicate - returns the last item matching the predicate in given collection

if no items are matching the predicate , then both first() and last() throw exceptions

in those exception cases , we can use firstOrNull() and lastOrNull() which returns null if predicate is not matching with any items in given collection

find() can be used instead of firstOrNull()

findLast() can be used instead of lastOrNull()

 val names = linkedSetOf("Sam", "Dev", "David", "Katherine", "Anne", "Chris")

    println(names.first {
        it.length > 5
    })
    // output : Katherine

    println(names.last{
        it.endsWith("id")
    })
    // output : David

    println(names.firstOrNull{
        it.contains("Ae")
    })
    // output : null

    println(names.lastOrNull(){
        it.length>15
    })
    // output : null

    println(names.find {
        it.length > 6
    })
    // output : Katherine

    println(names.findLast {
        it.endsWith("is")
    })
    // output : Chris

Selection

firstNotNullOf()

• maps the given collection with selector function

• returns the first non null value of mapped collection

firstNotNullOfOrNull()

• firstNotNullOf() throws NoSuchElementException if the result is null

    val names = linkedSetOf("Sam", "Dev", "David", "Katherine", "Anne", "Chris")

    val resultOne = names.firstNotNullOf { item ->
        item.length.takeIf { it > 6 }
    }
    println(resultOne)
    // output : 9

    val resultTwo = names.firstNotNullOfOrNull { item ->
        item.length.takeIf { it > 10 }
    }
    println(resultTwo)
    // output : null

Random

random() - gets a random item in collection

randomOrNull() - returns null if the given collection is empty

val names = linkedSetOf("Sam", "Dev", "David", "Katherine", "Anne", "Chris")

    println(names.random())

    val empty = linkedSetOf<String>()
    // println(empty.random())
    // output = Exception in thread 
    // "main" java.util.NoSuchElementException:
    //  Collection is empty.

    println(empty.randomOrNull())
    // output : null

Contains

contains()

• checks if the item is in collection

• returns true if the item matches the function argument

• use in keyword for operator form of contains()

containsAll()

• check multiple items together in given collection

isEmpty() / isNotEmpty()

• to check if the collection contains any element

val names = linkedSetOf("Sam", "Dev", "David", "Katherine", "Anne", "Chris")

    println(names.contains("Sam"))
    // output : true

    println("Anne" in names)
    // output : true

    println(names.containsAll(listOf("David", "Bob")))
    // output : false
    println(names.containsAll(listOf("David", "Chris")))
    // output : true

    val numbers = listOf(1, 2, 3, 4, 5, 6)
    println(numbers.isEmpty())
    // output : false
    println(numbers.isNotEmpty())
    // output : true

    val emptyList = emptyList<String>()
    println(emptyList.isEmpty())
    // output : true
    println(emptyList.isNotEmpty())
    // output : false

Please leave your comments to improve.

Happy and Enjoy coding

Slice

• returns the collection elements with the given indices in List<T>

we can slice with range values , range values with step count and we can do setOf() and listOf() also as follows

 val numbers = listOf(1,2,3,4,5,6,7,8,9)
    // slice int range
    println(numbers.slice(5..7))
    // output : [6, 7, 8]

    // slice step int range
    println(numbers.slice(0..6 step 2))
    //output : [1, 3, 5, 7]

    // slice setof
    println(numbers.slice(setOf(4,7,2,4)))
    // output : [5, 8, 3]

    // slice listOf
    println(numbers.slice(listOf(1,3,5,6,1)))
    //output: [2, 4, 6, 7, 2]

Take

take() - to get specified number of items from the beginning of input collection and returns List<T>

takeLast() - to get specified number/range of items from the end of input collection and returns List<T>

When we specify the number parameter larger than collection size , it returns the entire collection

takeWhile() - take() with predicate : it takes the items up to first item not matching predicate

takeLastWhile() - similar to takeLast() : first item of result is the next item to the last item not matching the predicate

   val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

    //take
    println(numbers.take(3))
    // output : [1, 2, 3]

    //takeLast
    println(numbers.takeLast(3))
    // output : [7, 8, 9]

    //take with parameter more than collection size
    println(numbers.take(11))
    // output : [1, 2, 3, 4, 5, 6, 7, 8, 9]

    // takeWhile
    println(
        numbers.takeWhile {
            it < 4
        }
    )
    // output : [1, 2, 3]

    // takeLastWhile
    println(
        numbers.takeLastWhile {
            it > 6
        }
    )
    //output : [6, 7, 8, 9]

Drop

drop() & dropLast()

• drops the given number if items from the input collection and returns List<T>

• drop() - drops from beginning of input collection

• dropLast() - drops from end of input collection

dropWhile()

• takes predicate

• returns the elements from the first items not matching predicate to the end of input collection

dropLastWhile()

• takes predicate

• returns the elements from beginning of collection to last item not matching the predicate

       val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
  
       // drop
        println(numbers.drop(4))
        // output : [5, 6, 7, 8, 9]
  
        // dropLast
        println(numbers.dropLast(6))
        // output : [1, 2, 3]
  
        //dropWhile
        println(
            numbers.dropWhile {
                it <= 7
            }
        )
        //output : [8, 9]
  
        // dropLastWhile
        println(
            numbers.dropLastWhile {
                it >= 6
            }
        )
        //output : [1, 2, 3, 4, 5]
  

Chunked

• breaks the collection into given size and returns list iof lists

• first chunk start from first item in collection

• last chunk may be of smaller size than given size

• we can apply transformation to the chunked part right away

• transformation lambda argument is chunk of collection and these chunked parts are scoped with lambda so we have to consume this with in lambda

        val numbers = (0..10).toList()
  
        // chunked
        println(numbers.chunked(3))
        //output :[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]
  
        // chunked with transformation
        val list = numbers.chunked(3) {
            it.average()
        }
        println(list)
        //output : [1.0, 4.0, 7.0, 9.5]
  

Windowed

• retrieves all possible range of collection values/elements of given input size (window size)

• returns list of items of the given size in a single list

Lets call each individual list in returned list as windows

step() - defines distance between first item of two adjacent windows and default step value is 1

partialWindows - include window of smaller size of last items at input collection end

Eg: if input collection is [0,1,2,3,4]and window size is 3 then the result is [0,1,2] , [1,2,3], [2,3,4],[3,4]

zipWithNext()

• used to build two element windows

• creates pair of adjacent items from input collection

• it creates a Pair for each element except the last one like [1,2],[2,3],[3,4] and not [1,2], [3,4]

  we can apply transformation to the windowed() and zipWithNext()

•       val numbers = (0..10).toList()
  
        // windowed
        println(numbers.windowed(3))
        // output : [[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], 
        //[4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]]
  
        // windowed with stop and partialWindows
        println(numbers.windowed(3, step = 3, partialWindows = true))
        // output : [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]
        println(numbers.windowed(3, step = 3, partialWindows = false))
        // output : [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
  
        // zipWithNext
        println(numbers.zipWithNext())
        // output : [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10)]
  
        // zipWithNext with transformation
        println(numbers.zipWithNext() { i1, i2 ->
            i1 + i2
        })
        // output : [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
  

Please leave your comments to improve.

Happy and Enjoy coding

Filtering a collection is an everyday task in dev life. In Kotlin , Filtering conditions are defined by predicates

predicate

• takes a collection value and returns a boolean value

  if it returns true -> given element matches predicate

  if it returns false -> given element not matches predicate

Filter by predicate

filter()

• when called with predicate , filter() returns the list of elements that matches the condition

• For both List and Set , the result is List

• For Map , the result is Map

   val numbers = listOf(62, 51, 67, 32, 45, 12)

    //filter for list and set
    val result = numbers.filter { it > 50 }
    println(result)
    //output: [62, 51, 67]

   val studentInfo = mapOf(
        "Student 1" to 18,
        "Student 99" to 19,
        "Student 101" to 21,
        "Student 199" to 23
    )
    //filter for map
    val seniorStudent = studentInfo.filter { (student, age) ->
        student.endsWith("9") && age > 20
    }
    println(seniorStudent)
    //output: {Student 199=23}

filterIndexed()

• If we need the element position in filter we can use filterIndexed()

• It takes the predicate with two arguments : index and value

   val numbers = listOf(62, 51, 67, 32, 45, 12)

    // filer indexed
    val filterIndexedResult = numbers.filterIndexed { index, i ->
        index != 0 && i > 60
    }
    println(filterIndexedResult)
    //output : [67]

filterNot()

• filter collections by negative conditions

• returns the list of all elements that predicate returned false

   val numbers = listOf(62, 51, 67, 32, 45, 12)

   //filterNot
    val filterNotResult = numbers.filterNot {
        it > 50
    }
    println(filterNotResult)
    //output : [32, 45, 12]

filterIsInstance()

• returns the collection of given type

• if we call on List<Any> with filterIsInstance<String>() , the result is list of strings i.e List<String>

    val typesList = listOf(1, null, "one", 'f', 3, null, 4.56, 78.9087, "twenty")

    //filterIsInstance
    val filterInstanceResult = typesList.filterIsInstance<Double>()
    println(filterInstanceResult)
    //output : [4.56, 78.9087]

filterNotNull()

• returns all non-nullable elements in the collection

• if we call on List<T> , it returns List<T : Any>

    val typesList = listOf(1, null, "one", 'f', 3, null, 4.56, 78.9087, "twenty")

    // filterNotNull
    val filterNotNullResult = typesList.filterNotNull()
    println(filterNotNullResult)
    //output: [1, one, f, 3, 4.56, 78.9087, twenty]

Partition

partition()

• filters the given collection by predicate and keeps the elements that does not match in a separate list

• returns pair of list , first one containing the elements matching the predicate and the second one not matching the predicate

    val numbers = listOf(23, 56, 34, 67, 12, 73, 8, 82, 45, 90)

    val partition = numbers.partition {
        it > 50
    }

    println(partition.first)
    //output : [56, 67, 73, 82, 90]
    println(partition.second)
    //output : [23, 34, 12, 8, 45]

Please leave your comments to improve.

Happy and Enjoy coding

Plus and Minus

• In Kotlin , + and - operators are used in collection

• The first operand is a collection where as second operand can either be an element or another collection

• returns a read only collection

Plus ( + )

• return a collection containing elements from both first and second operand

Minus ( - )

• returns a collection containing elements from original collection except the elements of second operand

• If the second operand is

  an element , minus remove its first occurrence

  a collection , all occurrence of its elements are removed

    val numberList = listOf(1, 3, 5, 7, 9)
    val numberOperand = listOf(3, 5)

    val plusResultList = numberList.plus(numberOperand)
    println(plusResultList)
    // output : [1, 3, 5, 7, 9, 3, 5]

    val minusResultList = numberList.minus(numberOperand)
    println(minusResultList)
    //output : [1, 7, 9]

    val number = 7
    val resultList = numberList.minus(number)
    println(resultList)
    //output : [1, 3, 5, 9]

Grouping

groupBy()

• takes a lambda function and returns a map

• In the Result

  key - lambda result

  value- list of elements on which the lambda result is obtained

       val numbers = listOf(22, 56, 44, 67, 88, 45, 77)
  
        // groupBy
        val groupByResult = numbers.groupBy {
            it % 11 == 0
        }
        println(groupByResult)
        //output : {true=[22, 44, 88, 77], false=[56, 67, 45]}
  

groupBy() - 2 Lambda argument

• Second lambda argument is a value transformation function

• In Result

  key - produced by keySelector function

  value - result of valueTransform function

    val numbers = listOf(22, 56, 44, 67, 88, 45, 77)

    val result = numbers.groupBy(
        keySelector = { it % 2 == 0 },
        valueTransform = {
            if (it % 2 == 0) {
                "$it is an Even number"
            } else {
                "$it is not an Even number"
            }
        })
    println(result)
    //output : {
//           true=[22 is an Even number,
//              56 is an Even number,
//              44 is an Even number,
//              88 is an Even number],
//           false=[67 is not an Even number,
//              45 is not an Even number,
//              77 is not an Even number]}

groupingBy()

• helps to group elements and apply an operation to all groups at one time

• returns an instance of Grouping type

• applies the operation in lazy manner : the groups are actually built right before the operation execution

• supports the following execution

  1.eachCount() - counts the element in each group

  2.fold() & reduce() - perform fold and reduce operations on each group as separate collection and return results

  3.aggregate() - applies a given operation subsequently to all elements in each group and return results

    val oddNumbers = listOf(1, 7, 5, 7, 9)
    val groupingByResult = oddNumbers.groupingBy {
        it * 2
    }.eachCount()

    println(groupingByResult)
    // output : {2=1, 14=2, 10=1, 18=1}

Please leave your comments to improve.

Happy and Enjoy coding

Kotlin Transformation function builds a new collection based on the transformation rules passed in the function.

Map

• Mapping transformation creates a collection from the result of function on the another collection's element

map()

• applies the given function to each element and returns the list of lambda result

• order of elements is same as order of original elements collection's order

 val numbers = setOf(1, 3, 2, 5, 4, 6, 7, 9, 0)
  // map
  println(numbers.map { it * 3 })
  //output ; [3, 9, 6, 15, 12, 18, 21, 27, 0]

mapIndexed()

• Apply a map() transformation that additionally uses the element index as argument

   val numbers = setOf(1, 3, 2, 5, 4, 6, 7, 9, 0) 
   //map indexed
    println(numbers.mapIndexed { index: Int, i: Int -> "index:$index - value:$i" })
    // output : [index:0 - value:1, index:1 - value:3, index:2 - value:2, index:3 - value:5,
    // index:4 - value:4, index:5 - value:6, index:6 - value:7, index:7 - value:9,
    // index:8 - value:0]

mapNotNull() & mapNotNullIndexed()

• If the transformation produces null on certain element , we can filter out null from result collection

    val numbers = setOf(1, 3, 2, 5, 4, 6, 7, 9, 0) 
    //map null
    println(numbers.mapNotNull { if (it == 5) null else it * 10 })
    // output : [10, 30, 20, 40, 60, 70, 90, 0]

    //map indexed null
    println(numbers.mapIndexedNotNull { index, i -> if (index == 4) null else i * 10 })
    // output : [10, 30, 20, 50, 60, 70, 90, 0]

When transforming maps , there are two options

1. mapKeys() -> transform key leaving values unchanged

2. mapValues() -> transform values leaving keys unchanged

   val numbersMap = mapOf("Key1" to 1, "Key2" to 2,
                "Key3" to 3, "Key4" to 4, "Key5" to 5)

    //map keys and map values
    println(numbersMap.mapKeys { it.key.reversed() })
    // output : {1yeK=1, 2yeK=2, 3yeK=3, 4yeK=4, 5yeK=5}
    println(numbersMap.mapValues { "${it.value} + ${it.key.uppercase()}" })
    // output : {Key1=1 + KEY1, Key2=2 + KEY2, Key3=3 + KEY3, 
    // Key4=4 + KEY4, Key5=5 + KEY5}

Zip

Zipping transformation is building pairs from elements with same positions in two collections

zip()

• returns the list of pair object

• if the collection have different sizes , then the result of zip() is smaller size collection size and the result will not contain the larger collection's last element

    val studentName = listOf("stu 1", "stu 2", "stu 3", "stu 4")
    val studentAge = listOf(20, 35, 5, 0, 30)
    // zip 
    println(studentName zip studentAge)
    // output : [(stu 1, 20), (stu 2, 35), (stu 3, 5), (stu 4, 0)]

• Zip with transformation function takes 2 parameters

  1.Receiver element

  2.Argument element

• Transformation function called on pairs of receiver and argument element with same position

    val studentName = listOf("stu 1", "stu 2", "stu 3", "stu 4")
    val studentAge = listOf(20, 35, 5, 0, 30)
    //zip transformation
    println(studentName.zip(studentAge) { name, age ->
        "The Student name is $name amd the age is $age"
    })
    // output : [The Student name is stu 1 amd the age is 20, 
    //The Student name is stu 2 amd the age is 35,
    // The Student name is stu 3 amd the age is 5, 
    //The Student name is stu 4 amd the age is 0]

unzip()

We can do the reverse transformation on the list of pairs and the result is of two lists

1.First list contains first element of each pair

2.Second list contains second element

    // unzipping
    val studentInfo = listOf(
        "stu1" to 20,
        "stu2" to 35,
        "stu3" to 5,
        "st4" to 0
    )
    println(studentInfo.unzip())
    // output : ([stu1, stu2, stu3, st4], [20, 35, 5, 0])

Associate

• Allow building maps from collection elements and values associated from them

associateWith()

• creates a map in which element of original collection are keys and values are result of given transformation function

    val numbers = listOf(1, 3, 5, 3, 7)

    // associateWith
    println(numbers.associateWith { it * 2 + 1 })
    // output : {1=2, 3=6, 5=10, 7=14}

associateBy()

• creates a map with original collection as values

• it takes a function that returns the key based on elements transformation function

    val numbers = listOf(1, 3, 5, 3, 7)

    // associateBy
    println(numbers.associateBy { it * 2 })
    //output :{2=1, 6=3, 10=5, 14=7}

associate()

• For building maps where both keys and values are produced from the original collection elements

• It takes a lambda function and returns a Pair: key and value of corresponding map entry

    val numbers = listOf(1, 3, 5, 3, 7)
    // associate
    println(numbers.associate {
        it to (it * 2 + 3)
       }
    )
    //output : {1=5, 3=9, 5=13, 7=17}

Flatten

• operates on nested collection that provide flat access to nested collection elements

flatten()

• call it on the collection of elements (list of sets)

• returns the list of elements in the nested collection

    val sampleSetList = listOf(
        setOf(3, 4, 5),
        setOf(0, 1, 2),
        setOf(7, 8, 9),
        setOf(6, 7, 8)
    )

    // flatten
    println(sampleSetList.flatten())
    //output : [3, 4, 5, 0, 1, 2, 7, 8, 9, 6, 7, 8]

flatMap()

• flexible way to process nested collection

• takes a function that maps a collection element to another collection

• returns a single list on its return values on all elements

• so basically flatMap() is a mixture of both map() and flatten()

    val containers = listOf(
        listOf("one", "two", "three"),
        listOf("four", "five", "six"),
        listOf("seven", "eight")
    )
   // flatmap
    println(containers.flatMap {
        it.asReversed()
    })
    // output : [three, two, one, six, five, four, eight, seven]

String Representation

• If we need collection in a readable format , use the transform function like joinTostring() and joinTo()

joinToString()

• builds a string string from the collection result based on provided argument

    val numbers = listOf("one", 1, "two", 2, "three", 3)

    // joinToString
    println(numbers.joinToString())
    // output : one, 1, two, 2, three, 3

joinTo()

• builds a string from collection but appends the result to the given append able object

• result is a string of collection elements separated by commas with spaces

    val numbers = listOf("one", 1, "two", 2, "three", 3)

    // joinTo
    val listContents = StringBuffer("The contents are -> ")
    numbers.joinTo(listContents)
    println(listContents)
    //output :The contents are -> one, 1, two, 2, three, 3

joinToString() - prefix, postfix and separator

• To build a custom string representation , we can user the prefix, postfix and separator in the joinToString()

   val numbers = listOf("one", 1, "two", 2, "three", 3)

   // joinToString
    println(
        numbers.joinToString(
            separator = " -- ",
            prefix = "Begin: ",
            postfix = " :End"
        )
    )
    //output: Begin: one -- 1 -- two -- 2 -- three -- 3 :End

joinToString() - limit and truncate

• This limit and truncate parameter is used in joinToString() for bigger collections , this will limit the elements in result

• if the limit is reached , truncated argument will replace the rest of all elements in the collection

   // limit and truncate 
    val numbersList = (1..100).toList()
    println(
        numbersList.joinToString(
            limit = 12, truncated = " and so on"
        )
    )
    //output ; 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,  and so on

joinToString() - transform

• To customize the elements in collections , we can use transform function as follows

// transform
    val numbersString = listOf("one", "two", "three")
    println(numbersString.joinToString { 
         "Element -> ${it.reversed().uppercase()}" 
      }
    )
    //output: Element -> ENO, Element -> OWT, Element -> EERHT

Please leave your comments to improve.

Happy and Enjoy coding

Collections are used to store and manipulate group of objects or data

Ordered Collection is the collection in which the position of each item is fixed Eg: Lists , Array , etc

Unordered Collection is the collection in which the position of each item is not fixed which means order of all elements are not maintained. Eg: Set

Collection Types

Immutable Collection

This collection supports read only functionality and we cannot modify its elements

List

• This is an ordered collection in which elements can be accessed using indices

• Elements can be repeated in list for any number of times

• We cannot perform add/remove operations in this immutable list

  listOf() , listOf<T>()

 val androidOsName = listOf(
        "Upside Down Cake",
        "Vanilla Ice Cream",
        "Tiramisu",
        "Snow Cone",
        "Red Velvet Cake"
    )

    for (name in androidOsName){
        println(name)
    }

Set

• This is an unordered collection in which elements cannot be duplicated

• Set is collection of unique elements

• We cannot perform add/remove operations because of immutable collection setOf()

 val android14Info  = setOf(
        "Android 14" ,
        "Upside Down Cake" ,
        14 ,
        34 ,
        "October 4 2023 "
    )

    for (name in android14Info){
        println(name)
    }

Map

• Maps are unordered collection of set of key/value pairs

• Map key are unique and can hold only one value for each key

• Keys are unique but values are duplicated

• Map is used to store logical collection between two objects

• As it is immutable , size is fixed and supports read only access .

  mapOf()

 val androidOsInfo = mapOf(
        13 to "Android 13 - Tiramisu - 13 - 33 - August 15, 2022 " ,
        12 to "Android 12 - Snow Cone - 12 - 31 - October 4, 2021 " ,
        11 to "Android 11 - Red Velvet Cake[24] - 11 - 30 tSeptember 8, 2020 "
    )

    for (info in androidOsInfo) {
        println("${info.key} -> ${info.value}")
    }

Mutable Collection

This collection supports both read and write functionality.

List

• This mutable list supports both read and write operation

• The declared elements in list can be either removed or added

  mutableListOf() , arrayListOf<T>() , ArrayList

 val androidOsName = mutableListOf(
        "Upside Down Cake",
        "Vanilla Ice Cream",
        "Tiramisu"
    )

    // modify item
    androidOsName[0] = "Pistachio Ice Cream"

    // add item
    androidOsName.add("Snow Cone")

    for (name in androidOsName){
        println(name)
    }

Set

• This set supports both read and write

• Set allows us to easily to add/remove elements

• Order of elements are preserved

  mutableSetOf() , hashSetOf()

val androidOsName = mutableSetOf<String>(
        "Upside Down Cake",
        "Vanilla Ice Cream",
        "Tiramisu"
    )

    // add item
    androidOsName.add("Snow Cone")

    // remove item
    androidOsName.remove("Upside Down Cake")

    for (name in androidOsName){
        println(name)
    }

Map

Since this Map is mutable and this supports operations like put, remove , clear ,etc

mutableMapOf() , hashMapOf() and HashMap

val androidOsInfo = mutableMapOf(
        13 to "Android 13 - Tiramisu - 13 - 33 - August 15, 2022 ",
        12 to "Android 12 - Snow Cone - 12 - 31 - October 4, 2021 ",
        11 to "Android 11 - Red Velvet Cake[24] - 11 - 30 tSeptember 8, 2020 "
    )

    // add item
    androidOsInfo.put(10, "Android 10 - Quince Tart[24] - 10 - 29 - September 3, 2019 ")

    // remove item
    androidOsInfo.remove(12)

    for (info in androidOsInfo) {
        println("${info.key} -> ${info.value}")
    }

So finally, I hope I made somebody understand the basics of kotlin collections

Please leave your comments to improve.

Happy and Enjoy coding

A simple student class as follows

class Student(var studentFirstName: String,
                                  var studentLastName: String = "No Name") {

    fun getStudentName(): String {
        return "$studentFirstName $studentLastName"
    }

    fun printStudentName() {
        println("$studentFirstName $studentLastName")
    }

    fun printStudentInfo() {
        println("Name:$studentFirstName $studentLastName)
    }

}

Now lets add a property to this class and understand the getters and setters behavior

Add a Property

Lets add a property age to the above class

var age : String= "0"

Now lets modify and print the age property from the main class

fun main(){
val student = Student("Vignesh", "Prabhu")
 println(student.age)
}
Console O/P:
0

Property Getter

Now lets add getter to this age property as follows

 var age = "0"
      get() {
            return "${getStudentName()}'s age is $field"
       }

In the above code , get() is called whenever we access this field . So we have manipulated the value of the property in a way that if we access the property age , then it will return as follows

fun main(){
val student = Student("Vignesh", "Prabhu")
println(student.age)
}
Console O/P:
Vignesh Prabhu's age is 0

In the above code we can observe that , we we accessed the property age and printed in the console shows Vignesh Prabhu's age is 0 because in the get method we have added the code return "${getStudentName()}'s age is $field".

Here $field is called backing field since the contains the value of property age

Property Setter

Now lets add setter to this age property as follows

 var age = "0"
  get() {...}
 set(value) {
            field = if (value == "0") {
                "unknown"
            } else {
                value
            }
        }

In the above code , set(value) is called whenever we want to modify the property in our own way . value is nothing but the passed value in the runtime. So lets see how it changes the property if we use this

fun main(){
  val student = StudentProperty("Vignesh", "Prabhu")
  println(student.age)
  student.age = "0"
  println(student.age)
}
Console O/P:
Vignesh Prabhu's age is 0
Vignesh Prabhu's age is unknown

As we can observe that when the value 0 is passed to age property , the set method takes over and manipulates the value wrt to the logic used.

Updated Student class:

class Student(var studentFirstName: String,
                                  var studentLastName: String = "No Name") {

    var age = "0"
        get() {
            return "${getStudentName()}'s age is $field"
        }
        set(value) {
            field = if (value == "0") {
                "unknown"
            } else {
                value
            }
        }


    fun getStudentName(): String {
        return "$studentFirstName $studentLastName"
    }

    fun printStudentName() {
        println("$studentFirstName $studentLastName")
    }

    fun printStudentInfo() {
        println("Name:$studentFirstName $studentLastName -------- Age:$age")
    }

}

So finally , I hope i made you understand property getter and setter in Kotlin.

Please leave your comments to improve.

Enjoy coding

Without a singleton, creating two different objects allocates two different object memories

In Kotlin, Singelton is made by using object keyword as follows

fun main(){

    println(Database) // prints Database@1c20c684
    val db = Database.getDatabaseName()
    println(db) // prints info.db
    println(Database) // prints Database@1c20c684
}

object Database{

    init {
        println("Database created")
    }

    private const val DATABASE_NAME = "info.db"

    fun getDatabaseName() = DATABASE_NAME

}

As you can see, the Database address is the same for two different calls in the above code

Things to note :

• an object class can have functions, properties and an init block

• the constructor method is not allowed

• properties and functions are called using the class name as we do in the companion object

Please leave your comments to improve.

Enjoy and happy coding

The lazy () block

fun main() {

    val bookInstance1 = Book(
        "Rogue Lawyer", "John Grisham", 2015
    ) // prints Book Rogue Lawyer class is called


    val bookInstance2 by lazy {
        Book(
            "The Rain maker", "John Grisham", 1995
        )
    }

    /*println(bookInstance2.getBookDetails())
    println(bookInstance1.getBookDetails())*/

}

class Book(
    var name: String,
    var author: String,
    var year: Int
) {

    init {
        println("Book $name class is called")
    }

    fun getBookDetails() {
        println(
            "-------------------------- \n" +
                    "Book Name : $name \n" +
                    "Author Name : $author \n" +
                    "Published Year :$year \n" +
                    "--------------------------"
        )
    }
}

In the above code, the bookInstance1 object is created when the object is initialized and bookInstance2 object is not created because the bookInstance2 is inside the lazy block which means bookInstance2 will be created only when bookInstance2.getBookDetails() is called

Things to note

• the lazy function takes a lambda and returns the lazy instance

• It can be used only with non-null variables

• val is allowed: var is not allowed

• object will be initialized only once and return the same values from the cache memory

• prevents unnecessary initialization of objects

Please leave your comments to improve.

Enjoy and happy coding

As observed from the above example,

• Members of companion object can be called simply by using the class name as a qualifier

• function inside companion object are called class variables or class functions because they don't belong to a specific object that you create with that class

• companion objects look like static members in other languages but in run time those are still instance members of real objects

• the members of companion object can be generated as real static methods or variables if you use the @ JVMStatic annotation

Please leave your comments to improve.

Enjoy and Happy coding