在Scala中使用从Java导入的不可变的“ val”

Question

I am using following example in Scala to show my confusion:

import java.util.HashMap
val jhm = new HashMap[String, Int]
jhm.put("myId", 1)
jhm.put("yourId", 2)

And it allows to add into "jhm"

Now if I do this in Scala:

val nmap = Map()
nmap += ("myId" -> 1)

It does not allow which is expected. My question: why does it allow changing immutable "val" in the first case ?

Answer 1

val creates an immutable reference, which means that this val will always point to the same object. It doesn't guarantee that the object itself will not change its own state.

Answer 2

put() on a HashMap mutates the map and doesn't return a new reference. In the second case you are adding a value to an immutable map, so a new map is returned. The Scala equivalent of your Java example would be:

import collection.mutable.Map

val nmap = Map()[String, Int]
nmap += ("a" -> 1)

Answer 3

you are mixing 2 different 'usages' of immutability.

you can have a mutable (var) or immutable (val) reference to something, and that something can be mutable or immutable itself.

ex:

var x = 3
x = 4 // it works, `x` can be reassigned 

val y = 3
y = 4 // it fails, `y` can't be reassigned

the problem is when that 'something', the reference' has an internal state. Primitive types like Int or String don't have this problem, but any class can have. scala collections are a common pain to new scala programmers, because there are mutable collections and immutable collections .

The difference is that any operation on an immutable collection returns a new collection, but the original remains the same, while in a mutable collection, the collection itself is modified.

In your case, the scala Map you are using is an immutable Map, and it doesn't contain such method. You can do myMap ++ (key -> value) and get a new Map.

A bigger confusion arises when you mix mutability in the references with mutability/state in the objects. You should play a bit yourself with things like:

val x1 = scala.collection.mutable.ListBuffer(1,2,3) // immutable reference to mutable object

// please, never use this in real code
var x2 = scala.collection.mutable.ListBuffer(1,2,3) // mutable reference to mutable object

// please, try to use this as much as possible
val x3 = scala.collection.immutable.List(1,2,3) // immutable reference to immutable object 

var x4 = scala.collection.immutable.List(1,2,3) // mutable reference to immutable object

if you have any doubts let me/us know so that we can help

Answer 4

Management Summary

You are not invoking the equivalent methods on equivalent classes. Use mutable.Map and replace += with put(...) and both will perform the same.

Detailed Answer

There are two distinct operations going on here. The first one is adding an element to a map. The method put(...) on the java Map is equivalent to the put(...) operation in scala, not + , which creates a new Map . The following is totally fine by the compiler:

val map = Map[Int, Int]()
map: scala.collection.mutable.Map[Int,Int] = Map()

map.put(1, 2)
res0: Option[Int] = None

map
res1: scala.collection.mutable.Map[Int,Int] = Map(1 -> 2)

By putting the the key value pair, map mutates its state. This does not cause your error. However you are not invoking the put(...) method, but += . This essentially means two operations:

1. call + method
2. assign the result to the variable

In contrast to put(...) ( ScalaDoc ) + ( ScalaDoc ) does not change the map, but creates a new one similar to immutable.Map . After creating the new Map, you try to re-assign it to a val , which raises your compiler error.

The same behaviour can be witnessed in java:

final int answer = 42;
answer = 23;

This will result in a compiler error java: cannot assign a value to final variable answer .