Scala深入学习之数组学习(二)

简介: 笔记

四、Map学习


在Scala中,把哈希表这种数据结构叫做映射。

Map是一个对偶,映射的k一v键值对的集合,在一个map中可以包含若干组k一v映射关系,前提条件是k不能重复。

Scala中的Map存储的内容是键值对(key一value),Scala中不可变的Map是有序的,可变的Map是无序的。Scala中,有可变Map (scala. collection. mutable. Map)和不可变Map(scala. collection. immutablE. Map)。

1.不可变映射

val personAges = Map("A1ice" -> 20 , "Job" -> 28 , "Garry " ->18)

上述代码构造出一个不可变的Map[String,Int],其值不能被改变。

也可以用此方法创建Map

val personAges = Map(("A1ice" -> 20),("Job" -> 28),("Garry" ->18))

注: ->用来创建元组,“sa” -> 1即(“Alice”,20)

2.可变映射

如果你想要一个可变映射,则用

val personAges = scala.collection.mutable.Map("A1ice"->20 , "Job"->28 , "Garry"->18)

如果想从一个空的映射开始,你需要选定一个映射实现并给出类型参数:

val personAgesI = new scala.collection.mutable.HashMap[String,Int]

在Scala中,映射是对偶的集合。对偶简单地说就是两个值构成的组,这两个值并不一定是同一个类型的,比如(“Alice”,20)

不可变Map示例代码:

package arrayDemo
/**
 * @author : 蔡政洁
 * @email :caizhengjie888@icloud.com
 * @date : 2020/9/16
 * @time : 3:19 下午
 */
object ImmutableMapOps {
  // Scala不可变map的操作
  def main(args: Array[String]): Unit = {
    val personMap = Map[String,Int](
      "张三"-> 20,
      "李四"-> 21,
      "王五"-> 22,
      "小白"-> 23
    )
    val key = "小白"
    if (personMap.contains(key)){
      // 获取map中的元素
      val optionAge:Option[Int] = personMap.get(key)
      val age1 = optionAge.get
      println(age1)
      // 获取map中的元素方式二
      val age2 = personMap(key)
      println(age2)
    } else {
      // 如果key存在,则获取对应的value,不存在,则返回默认值
      val age = personMap.getOrElse(key,-1)
      println(age)
    }
    // 不可变的map不能修改,增加操作
    // 删除,drop删除会返回一个新的集合,原集合不会改变
    println(personMap)
    println(personMap.drop(1))
    println(personMap)
  }
}

运行结果:

23
23
Map(张三 -> 20, 李四 -> 21, 王五 -> 22, 小白 -> 23)
Map(李四 -> 21, 王五 -> 22, 小白 -> 23)
Map(张三 -> 20, 李四 -> 21, 王五 -> 22, 小白 -> 23)

可变Map示例代码:

package arrayDemo
import scala.collection.mutable
/**
 * @author : 蔡政洁
 * @email :caizhengjie888@icloud.com
 * @date : 2020/9/16
 * @time : 4:07 下午
 */
object MutableMapOps {
  // Scala可变map操作
  def main(args: Array[String]): Unit = {
    val map = mutable.Map[String,Int](
      "张三"->23
    )
    println("原始map元素:"+map)
    // 添加元素
    map("李四") = 14
    println(map)
    // 修改元素
    map("李四") = 15
    println(map)
    // 存在即修改,不存在即添加
    map.put("小白",34)
    map.put("小黑",35)
    println(map)
    // 删除操作
    println("map.drop(1):"+map.drop(1)) // 删除集合中的起始集合,会返回一个新的集合,原集合不会改变
    println(map)
    val value:Option[Int] = map.remove("小白")
    // 如果有小白删除小白,原集合改变。如果没有小白,则返回-1
    println(value.getOrElse(-1))
    println(map)
    // map的遍历
    println("------scala的map遍历推荐方式一")
    val keys = map.keys
    for (key <- keys){
      val value = map(key)
      println(key+"---->"+value)
    }
    println("------scala的map遍历推荐方式二")
    for ((k,v) <- map){
      println(k+"---->"+v)
    }
    println("------scala的map遍历推荐方式三")
    for (kv <- map){
      println(kv._1+"---->"+kv._2)
    }
    println("------scala的map遍历推荐方式四")
    map.foreach(kv => {
      println(kv._1+"---->"+kv._2)
    })
  }
}

运行结果:

原始map元素:Map(张三 -> 23)
Map(张三 -> 23, 李四 -> 14)
Map(张三 -> 23, 李四 -> 15)
Map(张三 -> 23, 李四 -> 15, 小黑 -> 35, 小白 -> 34)
map.drop(1):Map(李四 -> 15, 小黑 -> 35, 小白 -> 34)
Map(张三 -> 23, 李四 -> 15, 小黑 -> 35, 小白 -> 34)
34
Map(张三 -> 23, 李四 -> 15, 小黑 -> 35)
------scala的map遍历推荐方式一
张三---->23
李四---->15
小黑---->35
------scala的map遍历推荐方式二
张三---->23
李四---->15
小黑---->35
------scala的map遍历推荐方式三
张三---->23
李四---->15
小黑---->35
------scala的map遍历推荐方式四
张三---->23
李四---->15
小黑---->35


五、元祖Tuple学习


映射是键/值对偶的集合。对偶足元组( tuple) 的最简单形态,元组是不同类型的值的聚集。元组的值是通过将单个的值包含在圆括号中构成的。例如: (1, 3.14,“Fred”)是一 一个元组,类型为:

Tuple3 [Int,Double,java.lang.String]

val t = (1, 3.14,"Fred")

需要注意的是:和数组或字符串中的位置不同,元组的各组元从1开始,而不是0。你可以把t._2写为t _2,即用空格而不是句点,但不能写成t_2

Tuple示例代码:

package arrayDemo
/**
 * @author : 蔡政洁
 * @email :caizhengjie888@icloud.com
 * @date : 2020/9/16
 * @time : 5:09 下午
 */
object TupleOps {
  // Scala集合体系之tuple元祖的操作
  def main(args: Array[String]): Unit = {
    // 构建一个元祖
    val tuple1 = new Tuple2[String,Int]("张三",13)
    val tuple2 = ("李四",15)
    // 获取元祖中的值
    val name = tuple1._1
    val age = tuple1._2
    println(s"name:${name},age:${age}")
    // 推荐元祖的定义的方式
    val tuple3 = ("spring","summer","autumn","winter")
    val (spring,summer,autumn,winter) = ("spring","summer","autumn","winter")
    println(spring == tuple3._1)
    println(summer == tuple3._2)
    println(autumn == tuple3._3)
    println(winter == tuple3._4)
    // 元祖的遍历,需要迭代器才能遍历
    for(t <- tuple3.productIterator){
      println(t)
    }
  }
}

运行结果:

name:张三,age:13
true
true
true
true
spring
summer
autumn
winter


六、zip学习


zip操作,就是将两个单列的集合,组合成双列的集合,集合中的每一组元素就是 上述学习过的tuple。


val province = Array("山东","河南","陕西","福建")
val capital = Array("济南","郑州","西安","福州")
// zip拉链操
val pcs = province.zip(capital)
for((p,c)<-pcs){
  print(p+"--->"+c)
}

zip示例代码:

package arrayDemo
/**
 * @author : 蔡政洁
 * @email :caizhengjie888@icloud.com
 * @date : 2020/9/16
 * @time : 7:49 下午
 */
object ZipOps {
  // scala zip 拉链操作
  def main(args: Array[String]): Unit = {
    val province = Array("山东","河南","陕西","福建")
    val capital = Array("济南","郑州","西安","福州","广州")
    val pcs:Array[(String,String)] = province.zip(capital) //会将两个集合裁剪到一样长
    for (pc <- pcs){
      val p = pc._1
      val c = pc._2
      println(s"province:${p},captial:${c}")
    }
    println("----------------zipAll----------------------")
    /**
     * zipAll会使用后面的参数对没有匹配上的值自动填充
     * 其中第一个元素(A),会和第二个集合中的多余的元素进行配对
     * 其中第二个元素(B),会和第一个集合中的多余的元素进行配对
     */
    val pcAll:Array[(String,String)] = province.zipAll(capital,"江苏","南京") //会将两个集合裁剪到一样长
    for (pc <- pcAll){
      val p = pc._1
      val c = pc._2
      println(s"province:${p},captial:${c}")
    }
  }
}

运行结果:

province:山东,captial:济南
province:河南,captial:郑州
province:陕西,captial:西安
province:福建,captial:福州
----------------zipAll----------------------
province:山东,captial:济南
province:河南,captial:郑州
province:陕西,captial:西安
province:福建,captial:福州
province:江苏,captial:广州
相关文章
|
算法 Scala
159 Scala数组
159 Scala数组
45 0
|
18天前
|
分布式计算 大数据 Java
大数据-87 Spark 集群 案例学习 Spark Scala 案例 手写计算圆周率、计算共同好友
大数据-87 Spark 集群 案例学习 Spark Scala 案例 手写计算圆周率、计算共同好友
32 5
|
18天前
|
分布式计算 关系型数据库 MySQL
大数据-88 Spark 集群 案例学习 Spark Scala 案例 SuperWordCount 计算结果数据写入MySQL
大数据-88 Spark 集群 案例学习 Spark Scala 案例 SuperWordCount 计算结果数据写入MySQL
41 3
|
5月前
|
Scala
scala-模式匹配(字符串、数组、元组、集合、类、偏函数)
scala-模式匹配(字符串、数组、元组、集合、类、偏函数)
25 0
|
6月前
|
Scala 容器
Scala学习--day04--集合、常用方法、案例实操 - WordCount TopN、不同省份的商品点击排行
Scala学习--day04--集合、常用方法、案例实操 - WordCount TopN、不同省份的商品点击排行
105 2
|
6月前
|
消息中间件 分布式计算 大数据
Scala学习--day03--函数式编程
Scala学习--day03--函数式编程
|
6月前
|
Java Scala
Scala学习--day02---控制流、“九层妖塔—杨辉三角”
Scala学习--day02---控制流、“九层妖塔—杨辉三角”
179 1
|
6月前
|
Java 编译器 API
Scala学习--day01变量与数据类型、运算符
Scala学习--day01变量与数据类型、运算符
|
分布式计算 算法 Hadoop
Scala数组和元组
Scala数组和元组
90 0