Regular Variable vs bear in mind vs bear in mind mutabableStateOf Comparisons

In composable operate, you may declare variables within the following methods:

• Regular variable
• Variable with bear in mind
• Variable with bear in mind mutableStateOf

var countNormal = getInitValue()

var countRemember = bear in mind { getInitValue() }

var countRememberMutableState by bear in mind { mutableStateOf(getInitValue()) }

getInitValue() is used to display whether or not it will get known as or executed throughout recomposition.

enjoyable getInitValue(): Int {
    Log.d("RememberExample", "getInitValue() is named!")
    return 0
}

What precisely are the variations?

Regular Variable

If you happen to make a change to countNormal, the variable is up to date. Nevertheless, it will not set off recomposition. If there’s recomposition happens (triggered by others), this entire line var countNormal = getInitValue() is executed.

In different phrases, getInitValue() is named once more and countNormal is reset again to 0. So countNormal is all the time 0 throughout recomposition.

bear in mind Variable

It’s much like regular variable above. WhencountRemember is up to date, it will not set off recomposition. The distinction is, throughout recomposition (triggered by others), it will not execute this entire line var countRemember = bear in mind { getInitValue() }. As an alternative, it will get the cache model of getInitValue().

In different phrases, getInitValue() will NOT be known as. The cached worth is assigned to countRemember variable. Thus, this variable is all the time reset again to 0 too throughout recomposition.

bear in mind mutableStateOf Variable

When countRememberMutableState is up to date, not solely this variable is up to date, it additionally triggers the recomposition IF there are listeners (it’s getting used someplace). Just like bear in mind variable above, it will get the cached model of MutableState and it will not name the mutableStateOf() once more.

Since this cached model of MutableStateobject has already been up to date, the worth will not be 0 anymore. In different phrases, countRememberMutableState has the up to date worth throughout recomposition.

Code Instance

It is a composable operate instance to display what I defined above.

@Composable
enjoyable RememberExample() {
    var countNormal = getInitValue()
    var countRemember = bear in mind { getInitValue() }
    var countRememberMutableState by bear in mind { mutableStateOf(getInitValue()) }

    Column {
        Textual content(textual content = "countNormal: $countNormal")
        Textual content(textual content = "countRemember: $countRemember")
        Textual content(textual content = "countRememberMutableState: ${countRememberMutableState}")

        Button(onClick = {
            ++countNormal
        }) { Textual content(textual content = "++countWithoutRemember") }

        Button(onClick = {
            ++countRemember

        }) { Textual content(textual content = "++countWithRemember") }

        Button(onClick = {
            ++countRememberMutableState
        }) { Textual content(textual content = "++countWithRememberMutableState.worth") }
    }
}

Abstract

Right here is the abstract after we ought to use bear in mind in my view.

Supply Code

GitHub Repository: Demo_UnderstandComposeConcept