What is the difference between var and val in Kotlin?


Kotlin Problem Overview

What is the difference between var and val in Kotlin?

I have gone through this link:

KotlinLang: Properties and Fields

As stated on this link:

> The full syntax of a read-only property declaration differs from a > mutable one in two ways: it starts with val instead of var and does > not allow a setter.

But just before there is an example which uses a setter.

fun copyAddress(address: Address): Address {
    val result = Address() // there's no 'new' keyword in Kotlin
    result.name = address.name // accessors are called
    result.street = address.street
    // ...
    return result

What is the exact difference between var and val?

Why do we need both?

This is not a duplicate of https://stackoverflow.com/questions/44178127/variables-in-kotlin-differences-with-java-var-vs-val as I am asking about the doubt related to the particular example in the documentation and not just in general.

Kotlin Solutions

Solution 1 - Kotlin

In your code result is not changing, its var properties are changing. Refer comments below:

fun copyAddress(address: Address): Address {
    val result = Address() // result is read only
    result.name = address.name // but not their properties.
    result.street = address.street
    // ...
    return result

val is same as the final modifier in java. As you should probably know that we can not assign to a final variable again but can change its properties.

Solution 2 - Kotlin

val and var both are used to declare a variable.

>var is like general variable and it's known as a mutable variable in kotlin and can be assigned multiple times. > >val is like Final variable and it's known as immutable in kotlin and can be initialized only single time.

For more information what is val and var please see below link > http://blog.danlew.net/2017/05/30/mutable-vals-in-kotlin/

Solution 3 - Kotlin

variables defined with var are mutable(Read and Write)

variables defined with val are immutable(Read only)

Kotlin can remove findViewById and reduce code for setOnClickListener in android studio. For full reference: Kotlin awesome features

value of mutable variables can be changed at anytime, while you can not change value of immutable variables.

where should I use var and where val ?

use var where value is changing frequently. For example while getting location of android device

var integerVariable : Int? = null

use val where there is no change in value in whole class. For example you want set textview or button's text programmatically.

val stringVariables : String = "Button's Constant or final Text"

Solution 4 - Kotlin

val use to declare final variable. Characteristics of val variables

  1. Must be initialized
  2. value can not be changed or reassign enter image description here

var is as a general variable

  1. We can initialize later by using lateinit modifier

    [lateinit also use for global variable we can not use it for local variable]

  2. value can be changed or reassign but not in global scope

enter image description here

val in kotlin is like final keyword in java

Solution 5 - Kotlin

val is immutable and var is mutable in Kotlin.

Solution 6 - Kotlin

You can easily think it as:

var is used for setter (value will change).

val is used for getter (read-only, value won't change).

Solution 7 - Kotlin

Simply think Val like final Variable in java

Solution 8 - Kotlin

|                |             val             |            var            |
| Reference type | Immutable(once initialized  | Mutable(can able to change|
|                | can't be reassigned)        | value)                    |
| Example        | val n = 20                  | var n = 20                |
| In Java        | final int n = 20;           | int n = 20;               |


Solution 9 - Kotlin

Simply, var (mutable) and val (immutable values like in Java (final modifier))

var x:Int=3
x *= x

//gives compilation error (val cannot be re-assigned)
val y: Int = 6

Solution 10 - Kotlin

If we declare variable using val then it will be read-only variable. We cannot change it's value. It's like final variable of Java. It's immutable.

But if we declare variable using var then it will be a variable which we can read or write. We can change it's value. It's mutable.

data class Name(val firstName: String, var lastName: String)

fun printName(name: Name): Name {
    val myName = Name("Avijit", "Karmakar") // myName variable is read only
    // firstName variable is read-only. 
    //You will get a compile time error. Val cannot be reassigned.
    myName.firstName = myName.firstName
    // lastName variable can be read and write as it's a var.
    myName.lastName = myName.lastName
    return myName

val cannot be initialized lately by the keyword lateinit but non-primitive var can be initialized lately by the keyword lateinit.

Solution 11 - Kotlin


  • var = variable, so it can change
  • val = value, so it can not change.

Solution 12 - Kotlin

>In Kotlin val is a read-only property and it can be accessed by a getter only. val is immutable.

#val example :

val piNumber: Double = 3.1415926
    get() = field

>However, var is a read-and-write property, so it can be accessed not only by a getter but a setter as well. var is mutable.

#var example :

var gravity: Double = 9.8
    get() = field
    set(value) { 
	    field = value 

#If you try to change an immutable val, IDE will show you error :

fun main() {	
    piNumber = 3.14          // ERROR

// RESULT:   Val cannot be reassigned 

#But a mutable var can be changed :

fun main() {	
    gravity = 0.0

// RESULT:   0.0

Hope this helps.

Solution 13 - Kotlin

Comparing val to a final is wrong!

vars are mutable vals are read only; Yes val cannot be reassigned just like final variables from Java but they can return a different value over time, so saying that they are immutable is kind of wrong;

Consider the following

var a = 10
a = 11 //Works as expected
val b = 10
b = 11 //Cannot Reassign, as expected

So for so Good!

Now consider the following for vals

val d
  get() = System.currentTimeMillis()

//Wait a millisecond
println(d) //Surprise!, the value of d will be different both times

Hence, vars can correspond to nonfinal variables from Java, but val aren't exactly final variables either;

Although there are const in kotlin which can be like final, as they are compile time constants and don't have a custom getter, but they only work on primitives

Solution 14 - Kotlin

var is like a general variable and can be assigned multiple times and is known as the mutable variable in Kotlin. Whereas val is a constant variable and can not be assigned multiple times and can be Initialized only single time and is known as the immutable variable in Kotlin.

Val: Assigned once (Read only)

Var: Mutable

example : define a variable to store userId value:

val userId = 1

if we are trying to change the variable userId you will get Error message

userId = 2
error: val cannot be reassigned // Error message!

Let’s create a new variable to store the name of the user:

var userName = "Nav"

if you want to reassign the value of userName you can easily do this because var is mutable

userName = "Van"

and now the value of userName is "Van".

For more information visit this: https://medium.com/techmacademy/kotlin-101-val-vs-var-behind-the-scenes-65d96c6608bf

Solution 15 - Kotlin

Value to val variable can be assigned only once.

val address = ���������������������������������������Address("Bangalore","India")
address = Address("Delhi","India") // Error, Reassigning is not possible with val

Though you can't reassign the value but you can certainly modify the properties of the object.

//Given that city and country are not val

That means you can't change the object reference to which the variable is pointing but the underlying properties of that variable can be changed.

Value to var variable can be reassigned as many times as you want.

var address = Address("Bangalore","India")
address = Address("Delhi","India") // No Error , Reassigning possible.

Obviously, It's underlying properties can be changed as long as they are not declared val.

//Given that city and country are not val

Solution 16 - Kotlin

Do you need to change a variable or set it permanently?

  • A good example if it is something like val pi5places = 3.14159 you would set it as val. Is there a possibility that you need to change that variable now or later, then you would set it as var.

  • For example : The color of a car, can be var colorCar = green. Later you can change that colorCar = blue, where as a val, you can not.

  • Responses here regarding mutable and immutable is fine, but may be scary if these terms are not well known or just getting into learning how to program.

Solution 17 - Kotlin

val property is similar to final property in Java. You are allowed to assign it a value only for one time. When you try to reassign it with a value for second time you will get a compilation error. Whereas var property is mutable which you are free to reassign it when you wish and for any times you want.

Solution 18 - Kotlin

Two ways to create variable in KOTLIN VAL and VAR

1.VAL stores constant values. Also called Final Variable

2.VAR stores Changeable Values

Click here for example

Solution 19 - Kotlin

val is immutable, final, the first assigned value cannot be changed.

val name:String = "andy"

name = "thomas" //Error: Val cannot be reassigned

var is mutable, reassignable, you can change the value over and over.

val a:Int = 1
var b:Int = 1
println("${a + b}") // output 2

b = 4
println("${a + b}") // output 5

> I think the easiest way to remember it : > > val = variable final > > var = variable reassignable, or the opposite of val.

Solution 20 - Kotlin

Both variables are used as initialising

  • val like a constant variable, It can be readable, and the properties of a val can be modified.

  • var just like a mutable variable. you can change the value at any time.

Solution 21 - Kotlin

Both, val and var can be used for declaring variables (local and class properties).

Local variables:

  1. val declares read-only variables that can only be assigned once, but cannot be reassigned.


val readonlyString = “hello”
readonlyString = “c u” // Not allowed for `val`

2. var declares reassignable variables as you know them from Java (the keyword will be introduced in Java 10, “local variable type inference”).


var reasignableString = “hello”
reasignableString = “c u” // OK

It is always preferable to use val. Try to avoid var as often as possible!

Class properties:

Both keywords are also used in order to define properties inside classes. As an example, have a look at the following data class:

data class Person (val name: String, var age: Int)

The Person contains two fields, one of which is readonly (name). The age, on the other hand, may be reassigned after class instantiation, via the provided setter. Note that name won’t have a corresponding setter method.

Solution 22 - Kotlin

val like constant variable, itself cannot be changed, only can be read, but the properties of a val can be modified; var just like mutant variable in other programming languages.

Solution 23 - Kotlin

Var means Variable-If you stored any object using 'var' it could change in time.

For example:

fun main(args: Array<String>) {
    var a=12
    var b=13
    var c=12
    a=c+b **//new object 25**

Val means value-It's like a 'constant' in java .if you stored any object using 'val' it could not change in time.

For Example:

fun main(args: Array<String>) {
    val a=12
    var b=13
    var c=12
    a=c+b **//You can't assign like that.it's an error.**

Solution 24 - Kotlin

In short, val variable is final (not mutable) or constant value that won't be changed in future and var variable (mutable) can be changed in future.

class DeliveryOrderEvent(val d : Delivery)
// Only getter

See the above code. It is a model class, will be used for data passing. I have set val before the variable because this variable was used to get the data.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

Also, if you need to set data later you need to use var keyword before a variable, if you only need to get the value once then use val keyword

Solution 25 - Kotlin


  • Val is using for static field like in Java as Static Keyword

  • Like Static in Java/ Same as in kotlin

  • And Var denotes Variable Field in Kotlin that, you can change it.

  • Mostly Static is used when you want to save value in static memory at once,


 if you assign

 val a=1
 a=3  You can not change it 
  • You can not change, this is final value and Static

    var b=2

    b=4 U can change it

Solution 26 - Kotlin

val : must add or initialized value but can't change. var: it's variable can ba change in any line in code.

Solution 27 - Kotlin

In kotlin we can declare variable in two types: val and var. val cannot be reassigned, it works as a final variable.

val x = 2
x=3 // cannot be reassigned

On the other side, var can be reassigned it is mutable

var x = 2
x=3 // can be reassigned

Solution 28 - Kotlin

Both are variable the only difference is that Mutable variable and immutable variable and there is nothing more difference. var is Mutable variable and val is immutable.In simple Language var can change is value after initialization value val is constant and it cannot change it value after initialization the value.

Solution 29 - Kotlin

val (from value): Immutable reference. A variable declared with val can’t be reassigned after it’s initialized. It corresponds to a final variable in Java.

var (from variable): Mutable reference. The value of such a variable can be changed. This declaration corresponds to a regular (non-final) Java variable.

Solution 30 - Kotlin

VAR is used for creating those variable whose value will change over the course of time in your application. It is same as VAR of swift, whereas VAL is used for creating those variable whose value will not change over the course of time in your application.It is same as LET of swift.

Solution 31 - Kotlin

val - Immutable(once initialized can't be reassigned)

var - Mutable(can able to change value)


in Kotlin - val n = 20 & var n = 20

In Java - final int n = 20; & int n = 20;

Solution 32 - Kotlin

var is a mutable variable and can be assigned multiple times and val is immutable variable and can be intialized only single time.

Solution 33 - Kotlin

In Kotlin we use var to declare a variable. It is mutable. We can change, reassign variables. Example,

fun main(args : Array<String>){
    var x = 10

    x = 100 // vars can reassign.

We use val to declare constants. They are immutable. Unable to change, reassign vals. val is something similar to final variables in java. Example,

fun main(args : Array<String>){
    val y = 10

    y = 100 // vals can't reassign (COMPILE ERROR!).

Solution 34 - Kotlin

I get the exact answer from de-compiling Kotlin to Java.

If you do this in Kotlin:

data class UsingVarAndNoInit(var name: String)
data class UsingValAndNoInit(val name: String)

You will get UsingVarAndNoInit:

package classesiiiandiiiobjects.dataiiiclasses.p04variiiandiiival;

import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

public final class UsingVarAndNoInit {
  @NotNull private String name;

  public final String getName() {
    return this.name;

  public final void setName(@NotNull String string) {
    Intrinsics.checkParameterIsNotNull((Object) string, (String) "<set-?>");
    this.name = string;

  public UsingVarAndNoInit(@NotNull String name) {
    Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
    this.name = name;

  public final String component1() {
    return this.name;

  public final UsingVarAndNoInit copy(@NotNull String name) {
    Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
    return new UsingVarAndNoInit(name);

  public static /* bridge */ /* synthetic */ UsingVarAndNoInit copy$default(
      UsingVarAndNoInit usingVarAndNoInit, String string, int n, Object object) {
    if ((n & 1) != 0) {
      string = usingVarAndNoInit.name;
    return usingVarAndNoInit.copy(string);

  public String toString() {
    return "UsingVarAndNoInit(name=" + this.name + ")";

  public int hashCode() {
    String string = this.name;
    return string != null ? string.hashCode() : 0;

  public boolean equals(Object object) {
        if (this == object) break block2;
        if (!(object instanceof UsingVarAndNoInit)) break block3;
        UsingVarAndNoInit usingVarAndNoInit = (UsingVarAndNoInit) object;
        if (!Intrinsics.areEqual((Object) this.name, (Object) usingVarAndNoInit.name)) break block3;
      return true;
    return false;

You will also get UsingValAndNoInit:

package classesiiiandiiiobjects.dataiiiclasses.p04variiiandiiival;

import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

public final class UsingValAndNoInit {
  @NotNull private final String name;

  public final String getName() {
    return this.name;

  public UsingValAndNoInit(@NotNull String name) {
    Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
    this.name = name;

  public final String component1() {
    return this.name;

  public final UsingValAndNoInit copy(@NotNull String name) {
    Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
    return new UsingValAndNoInit(name);

  public static /* bridge */ /* synthetic */ UsingValAndNoInit copy$default(
      UsingValAndNoInit usingValAndNoInit, String string, int n, Object object) {
    if ((n & 1) != 0) {
      string = usingValAndNoInit.name;
    return usingValAndNoInit.copy(string);

  public String toString() {
    return "UsingValAndNoInit(name=" + this.name + ")";

  public int hashCode() {
    String string = this.name;
    return string != null ? string.hashCode() : 0;

  public boolean equals(Object object) {
        if (this == object) break block2;
        if (!(object instanceof UsingValAndNoInit)) break block3;
        UsingValAndNoInit usingValAndNoInit = (UsingValAndNoInit) object;
        if (!Intrinsics.areEqual((Object) this.name, (Object) usingValAndNoInit.name)) break block3;
      return true;
    return false;

There are more examples here: https://github.com/tomasbjerre/yet-another-kotlin-vs-java-comparison

Solution 35 - Kotlin

Lets try this way.

Val is a Immutable constant 
    val change="Unchange" println(change)
    //It will throw error because val is constant variable
    // change="Change" 
    // println(change)
Var is a Mutable constant
    var name: String="Dummy"

Solution 36 - Kotlin

I'm late to the party, but there's one difference that I haven't seen mentioned. You can use val to assign a local variable in a when expression, but trying to use var will produce a compiler error:

sealed class Token {
    data class StringToken(val value: String) : Token()
    data class BoolToken(val value: Boolean) : Token()

fun getToken() : Token = Token.BoolToken(true)

val output = when (val token = getToken()) {
    is Token.StringToken -> token.value
    is Token.BoolToken -> token.value.toString()

This allows you to get access to the correctly type-inferred value in the expressions on the right.

Solution 37 - Kotlin

Var is a mutable variable. It is a variable that can be changed to another value. It's similar to declaring a variable in Java.

Val is a read-only thing. It's similar to final in java. A val must be initialized when it is created. This is because it cannot be changed after it is created.

var test1Var = "Hello"
test1Var = "GoodBye"
val test2Val = "FinalTestForVal";

Solution 38 - Kotlin

We use var to declare variables and we use val to create constants which in java are preceded by the reserved word final

Solution 39 - Kotlin

Val is immutable and its properties are set at run time, but you can use a const modifier to make it as a compile time constant. Val in kotlin is same as final in java.

Var is mutable and its type is identified at compile time.

Solution 40 - Kotlin

In Kotlin, we have two types of variables: var or val. The first one, var, is a mutable reference (read-write) that can be updated after initialization. The var keyword is used to define a variable in Kotlin. It is equivalent to a normal (nonfinal) Java variable. If our variable needs to change at some time, we should declare it using the var keyword. Let's look at an example of a variable declaration:

 fun main(args: Array<String>) {
     var fruit:String = "orange"  // 1
     fruit = "banana"             // 2

Solution 41 - Kotlin

var is a variable like any other language. eg.

var price: Double

On the other side, val provides you feature of referencing. eg.

// You refer this to get constant value 7. In this case, val acts as access
// specifier final in Java


val Int.absolute: Int
    get() {
        return Math.abs(this)
// You refer to the newly create 'method' which provides absolute value 
// of your integer

println(-5.absolute) // O.P: 5


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionAkshar PatelView Question on Stackoverflow
Solution 1 - Kotlinchandil03View Answer on Stackoverflow
Solution 2 - KotlinPatel PinkalView Answer on Stackoverflow
Solution 3 - Kotlinuser6435056View Answer on Stackoverflow
Solution 4 - Kotlinuser4696837View Answer on Stackoverflow
Solution 5 - KotlinSamir MangroliyaView Answer on Stackoverflow
Solution 6 - KotlinLing BooView Answer on Stackoverflow
Solution 7 - KotlinConnecting life with AndroidView Answer on Stackoverflow
Solution 8 - KotlinJoby Wilson MathewsView Answer on Stackoverflow
Solution 9 - KotlinhuseyinView Answer on Stackoverflow
Solution 10 - KotlinAvijit KarmakarView Answer on Stackoverflow
Solution 11 - KotlinBharat SonawaneView Answer on Stackoverflow
Solution 12 - KotlinAndy JazzView Answer on Stackoverflow
Solution 13 - KotlinVishal AmbreView Answer on Stackoverflow
Solution 14 - KotlinNaveen kumarView Answer on Stackoverflow
Solution 15 - KotlinSaurabh PadwekarView Answer on Stackoverflow
Solution 16 - KotlinteckeonView Answer on Stackoverflow
Solution 17 - KotlinHalil RAŞOView Answer on Stackoverflow
Solution 18 - KotlinColtin CasmirView Answer on Stackoverflow
Solution 19 - KotlinWahyu Anggara RayaView Answer on Stackoverflow
Solution 20 - KotlinNikhil KatekhayeView Answer on Stackoverflow
Solution 21 - Kotlins1m0nw1View Answer on Stackoverflow
Solution 22 - KotlinsuyanluView Answer on Stackoverflow
Solution 23 - KotlinNHB SOHELView Answer on Stackoverflow
Solution 24 - KotlinShaonView Answer on Stackoverflow
Solution 25 - KotlinZafar HussainView Answer on Stackoverflow
Solution 26 - KotlinMohamed IbrahimView Answer on Stackoverflow
Solution 27 - KotlinMarium JawedView Answer on Stackoverflow
Solution 28 - KotlinNickView Answer on Stackoverflow
Solution 29 - KotlinGulzar BhatView Answer on Stackoverflow
Solution 30 - KotlinAshutosh ShuklaView Answer on Stackoverflow
Solution 31 - KotlinNajib.NjView Answer on Stackoverflow
Solution 32 - KotlinYohan MalshikaView Answer on Stackoverflow
Solution 33 - KotlinOsusara KammalawattaView Answer on Stackoverflow
Solution 34 - KotlinTomas BjerreView Answer on Stackoverflow
Solution 35 - Kotlinuser10480468View Answer on Stackoverflow
Solution 36 - KotlinNickLView Answer on Stackoverflow
Solution 37 - KotlinMarcus ThorntonView Answer on Stackoverflow
Solution 38 - KotlinElizeu SantosView Answer on Stackoverflow
Solution 39 - KotlinVarun ChandranView Answer on Stackoverflow
Solution 40 - KotlinPrakash ShuklaView Answer on Stackoverflow
Solution 41 - KotlinMukund DesaiView Answer on Stackoverflow