blocks|key|1575971|text|我认为它被声明为val是因为列表将始终是相同的，唯一变化的是它的元素。你永远不会做这样的事情：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1575972|joblist+=+anotherList|code-block|syntax|javascript|1575973|例如：|1575974|data+class+Example(var+name:+String)

val+exampleObject+=+Example("SomeName")|1575975|你仍然可以这样做：|1575976|exampleObject.name+=+"AnotherName"|1575977|但你不能这样做：|1575978|exampleObject+=+anotherObject|1575979|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I think it's declared as val because the list will be the same always, the only thing that changes is it's elements. You'll never do something like:

<pre><code>joblist = anotherList
</code></pre>

And as @Taseer said, the properties of the object can be changed even if it's a val. For example:

<pre><code>data class Example(var name: String)

val exampleObject = Example("SomeName")
</code></pre>

You'll still be able to do this:

<pre><code>exampleObject.name = "AnotherName"
</code></pre>

But you can't do this:

<pre><code>exampleObject = anotherObject
</code></pre>

blocks|key|1576007|text|简而言之，没有规则，这取决于你|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1576008|如果使用val，则可以修改mutableList，但不能重新分配|offset|length|style|CODE|1576009|如果您需要将另一个列表重新赋值给同一变量，请使用var。在大多数情况下，您并不需要它，这就是您的团队经常使用它的原因|1576010|entityMap^0|0|4|3|D|B|0|O|3|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|K|$]]

In short - there are no rules, its up to you

if you use <code>val</code> you can modify <code>mutableList</code>, but not reassign

if you need reassign another list to same variable, use <code>var</code>. In most cases you dont need it, thats why your team uses it frequently

blocks|key|1576373|text|由于其他答案和评论中给出的原因，val更加惯用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1576374|您说val没有实例化，但在示例代码中，它是实例化的。|1576375|val+jobList+=+mutableListOf<JobActivity>()|code-block|syntax|javascript|1576376|是实例化空MutableList<JobActivity>的工厂|1576377|使用这种模式(val而不是var，在声明时实例化)可以确保您的代码永远不会为jobList找到一个未初始化或null值；编译器可以证明这一点。|1576378|entityMap^0|G|3|0|0|0|5|O|0|7|3|D|3|12|7|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|R|$]]

<code>val</code> is more idiomatic for the reasons given in other answers and comments.

You said the val is not instantiated, but in your example code, it is.

<pre><code>val jobList = mutableListOf&lt;JobActivity&gt;()
</code></pre>

is a factory that instantiates an empty <code>MutableList&lt;JobActivity&gt;</code>

Using this pattern (<code>val</code> not <code>var</code>, instantiated upon declaration) ensures that your code will never find an uninitialized or null value for <code>jobList</code>; and the compiler can prove it.

blocks|key|1576482|text|您可以使用var创建一个可变的变量(可以更改)。可变意味着变量可以在将来更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1576483|当变量将来不会改变时，使用val，这意味着常量或最终变量。|1576484|这里的changed意味着新的值或新的东西将被赋值给变量，但是|1576485|val+list+=+mutableListOf()|code-block|syntax|javascript|1576486|在这个列表变量中，你指定了可变列表。您刚刚更改了列表的值。但是您没有将新的实例或新值赋给您刚刚添加的变量或从列表中删除的值。就这样。所以这里的list本身是不可变的。|1576487|如果你像下面这样做，它将是可变的。|1576488|var+list+=+mutableListOf()
list+=+mutableListOf()|1576489|对同一变量进行两次初始化。|1576490|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|10|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

You create a variable with var that is mutable (that can change). Mutable means variable can be changed in future. 

val is used when variable will not be changed in future that means constant or final.

Here changed means new value or new things will be assigned to the variable but 

<pre><code>val list = mutableListOf()
</code></pre>

in this list variable you assigned mutable list. You just changed the value of the list. But you didn't assign new instance or new value to the variable you just added and remove value from the list. That's it. So here list is immutable itself. 

It will be mutable if you do things like below... 

<pre><code>var list = mutableListOf()
list = mutableListOf()
</code></pre>

Two initialization on the same variable.

blocks|key|1576498|text|变量是var还是val可以区分变量的值(引用)可以更改(var+=可变)或不可更改(val+=不可变)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1576499|您应该始终努力使用val而不是var，以避免不必要的副作用(例如，在另一个线程中更改它)。|1576500|在使用MutableList的情况下，您最有可能使用val，因为您不希望改变对列表的引用，而是希望改变列表的内容。|1576501|下面是您的选项概述：|1576502|//+Do+you+want+to+change+its+reference+(r)+/+contents+(c)?
var+a+=+mutableListOf(1,+2,+3)+//+r+=+yes,+c+=+yes
var+b+=+listOf(1,+2,+3)++++++++//+r+=+yes,+c+=+no
val+c+=+mutableListOf(1,+2,+3)+//+r+=+no,++c+=+yes
val+d+=+listOf(1,+2,+3)++++++++//+r+=+no,++c+=+no|code-block|syntax|javascript|1576503|entityMap^0|3|3|8|3|S|3|16|3|0|9|3|F|3|0|3|B|Q|3|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1B|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1C|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|R|$]]

Whether a variable is <code>var</code> or <code>val</code> distinguishes between a variable of which the value (reference) can be changed (<code>var</code> = mutable) or not (<code>val</code> = immutable).

You should always strive to use <code>val</code> over <code>var</code> to avoid unwanted side-effects (changing it in another thread for example).

In case of the <code>MutableList</code> you should most likely use a <code>val</code>, because you don't want to mutate the reference to the list but rather its contents.

Here an overview of your options:

<pre><code>// Do you want to change its reference (r) / contents (c)?
var a = mutableListOf(1, 2, 3) // r = yes, c = yes
var b = listOf(1, 2, 3) // r = yes, c = no
val c = mutableListOf(1, 2, 3) // r = no, c = yes
val d = listOf(1, 2, 3) // r = no, c = no
</code></pre>

I am reading through the existing codebase for my team, and I notice <code>mutableListOf</code> are always declared as <code>val</code>. In some scenarios, elements are added to the <code>mutableListOf</code> only once. E.g

<pre><code>val jobList = mutableListOf&lt;JobActivity&gt;()
jobList.addAll(job.activities)
</code></pre>

In other scenarios, elements are added to <code>mutableListOf</code> in a loop. E.g

<pre><code>val jobList = mutableListOf&lt;JobActivity&gt;()
newJobList.filterScanType(retrieveJobType(JobContext.NEW)).forEach {
 jobList.add(it)
}
</code></pre>

Since the list is not initialized on creation, why not declare <code>mutableListOf</code> as <code>var</code>? A lot of examples found online also follow the same pattern of declaring <code>mutableListOf</code> as <code>val</code>. 

Which is best to use in the 2 scenarios described, <code>val</code> or <code>var</code>?

Kotlin: Should mutableList be declared as Val or Var?

编译器

我正在阅读我的团队的现有代码库，我注意到mutableListOf总是被声明为val。在某些情况下，元素仅添加到mutableListOf中一次。E.gval jobList = mutableListOf<JobActivity>()jobList.addAll(job.activities)在其他场景中，元素以循环...

问mutableList应该声明为Val还是Val？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问mutableList应该声明为Val还是Val？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问mutableList应该声明为Val还是Val？
EN