Map is an iterative set of key value pairs. Using maps in scala is very simple.
Construct Map
//Immutable map (immutable map, immutable value)
// With initial value
// In scala, the - > operator is used to create key value pairs of tuples.
val inmutableMap = Map(("yoleen" -> 20), ("hq", 26))
// It does not have an initial value, and it is not recommended to build such an immutable Map. Immutable Map add data all return a new Map.
val stringToInt = new scala.collection.immutable.HashMap[String, Int]
//mutable Map (mutable Map, add, delete, update elements return to themselves)
val mutableMap: mutable.Map[String, Int] = scala.collection.mutable.Map(("yoleen" -> 20), ("hq", 26))
//No initial value
val stringToInt = new scala.collection.mutable.HashMap[String, Int]
//If you have an initial value, you don't need to use new
Get value in map
val mutableMap: mutable.Map[String, Int] = scala.collection.mutable.Map(("yoleen" -> 20), ("hq", 26))
val v: Option[Int] = mutableMap.get("yoleen") //If the key exists and returns some object, the result is encapsulated. There is no None returned
val v1: Int = mutableMap("yoleen")// Use the apply method to get the value without option encapsulation.
val v2: Int = mutableMap.getOrElse("yoleen", 10)//Return the default value if the key does not exist
val v3: Int = mutableMap.getOrElseUpdate("yoleen1",op(5,6))//If the key does not exist, return the default value and add it to the map.
Add & update values in map
val mutableMap: mutable.Map[String, Int] = scala.collection.mutable.HashMap[String,Int]
mutableMap+=("yoleen"->10)
mutableMap+=("yoletpig"->10,"alex"->20) //Add multiple key value pairs
mutableMap++=mutable.Map(("tony" -> 20), ("jskon", 26)) //Add all key value pairs in another map.
mutableMap.put("kudu",6)//Update value if key exists
mutableMap("yoleen") = 20//Update value
mutableMap.transform((s, i) => i * 2)//Perform * 2 operation on the value corresponding to each key
Remove key value pair
mutableMap-="yoleen"
mutableMap-=("yoletpig","jskon") //Remove multiple key value pairs
val option: Option[Int] = mutableMap.remove("kudu") //Remove key value pair return option object
mutableMap.retain((s,i)=>s.startsWith("y") && i>=10) //Only key value pairs that start with "y" and have a value greater than or equal to 10 are reserved
mutableMap.clear()//Clear all key value pairs
Iterative mapping
for (elem <- mutableMap) {
elem // tuple type (String,Int)
}
for ((k,v) <- mutableMap) {
//k. V follow value
}
for (elem <- mutableMap.keySet) {
//elem is key
}
for (elem <- mutableMap.values) {
//elem is value
}
Other mappings
In addition to the commonly used HashMap, there are SortMap, LinkedHashMap, TreeMap and so on.
- SortMap accesses the keys in the map in order.
- LinkedHashMap is accessed in the order of insertion.
- TreeMap key sort.
If you need to interoperate with java, just add implicit transformation.
import scala.collection.JavaConversions.mapAsScalaMap
Tuple
The value of a tuple is constructed by including a single value in (). For example:
(1,3.14,"hello") //Unlimited types val t = (1,3.14,"hello") //We can go through it_ 1 ._ 2 to access elements in tuples val a = t._1 // 1 val b = t._2 // 3.14 //Note that the tuple subscript starts at 1. //We can use pattern matching to get values in tuples. val (first,_,third) = t // first=1,third="hello"
Zipper operation of tuples
val sy = Array("<","-",">")
val cnt = Array(2,3,2)
val pairs = sy.zip(cnt) //Array(("<",2),("-",3),(">",2))
for((s,n)<-pairs) print(s*n) // <<--->>