大数据学习指南
  • README
  • Storm
    • Storm和流处理简介
    • Storm集成Kakfa
    • Storm集群环境搭建
    • Storm编程模型详解
    • Storm核心概念详解
    • Storm三种打包方式对比分析
    • Storm集成Redis详解
    • Storm集成HBase和HDFS
    • Storm单机环境搭建
  • HBase
    • HBase过滤器详解
    • HBase的 SQL 中间层Phoenix
    • HBase常用 Shell 命令
    • HBase系统架构及数据结构
    • HBase集群环境搭建
    • HBase容灾与备份
    • HBase Java API
    • HBase协处理器详解
    • Spring Boot 整合 Mybatis + Phoenix
    • HBase简介
    • HBase单机环境搭建
  • Flink
    • Flink 窗口模型
    • Flink 状态管理与检查点机制
    • Flink核心概念综述
    • Flink开发环境搭建
    • Flink Sink
    • Flink Data Source
    • Flink 中使用 RocksDB 状态后端
    • Flink Transformation
    • Flink Standalone 集群部署
  • Spark
    • Spark SQL
      • Spark SQL JOIN操作
      • DataFrame和Dataset简介
      • Spark SQL 常用聚合函数
      • Structured API基本使用
      • Spark SQL 外部数据源
    • Spark Streaming
      • Spark Streaming 基本操作
      • Spark Streaming 整合 Flume
      • Spark Streaming 整合 Kafka
      • Spark Streaming 简介
    • Spark Core
      • Transformation 和 Action 常用算子
      • Spark累加器与广播变量
      • 基于ZooKeeper搭建Spark高可用集群
      • Spark运行模式与作业提交
      • Spark开发环境搭建
      • 弹性式数据集RDD
      • Spark简介
  • Scala
    • 类和对象
    • 集合类型
    • 隐式转换和隐式参数
    • 流程控制语句
    • 继承和特质
    • 函数 & 闭包 & 柯里化
    • Scala数组
    • Scala基本数据类型和运算符
    • 模式匹配
    • Scala List & Set
    • Scala简介及开发环境配置
    • 类型参数
    • Scala Map & Tuple
  • Hive
    • Hive实现WordCount详解
    • Hive常用DDL操作
    • Hive视图和索引
    • Linux环境下Hive的安装部署
    • HiveCLI和Beeline命令行的基本使用
    • Hive常用DML操作
    • Hive分区表和分桶表
    • Hive简介及核心概念
    • Hive数据查询详解
    • Hive SQL的编译过程
  • Hadoop
    • 分布式计算框架—MapReduce
    • HDFS Java API 的使用
    • Hadoop单机环境搭建
    • HDFS常用Shell命令
    • Hadoop极简入门
    • MapReduce编程模型和计算框架架构原理
    • 基于Zookeeper搭建Hadoop高可用集群
    • Hadoop集群环境搭建
    • 集群资源管理器—YARN
    • Hadoop分布式文件系统—HDFS
  • 前言
    • 大数据框架对比:Hadoop、Storm、Samza、Spark和Flink
由 GitBook 提供支持
在本页
  • 1. 映射(Map)
  • 1.1 构造Map
  • 1.2 获取值
  • 1.3 新增/修改/删除值
  • 1.4 遍历Map
  • 1.5 yield关键字
  • 1.6 其他Map结构
  • 1.7 可选方法
  • 1.8 与Java互操作
  • 2. 元组(Tuple)
  • 2.1 模式匹配
  • 2.2 zip方法
  • 3. 参考资料

这有帮助吗?

  1. Scala

Scala Map & Tuple

上一页类型参数下一页Hive

最后更新于4年前

这有帮助吗?

转载:

1. 映射(Map)

1.1 构造Map

// 初始化一个空 map
val scores01 = new HashMap[String, Int]

// 从指定的值初始化 Map(方式一)
val scores02 = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

// 从指定的值初始化 Map(方式二)
val scores03 = Map(("hadoop", 10), ("spark", 20), ("storm", 30))

采用上面方式得到的都是不可变 Map(immutable map),想要得到可变 Map(mutable map),则需要使用:

val scores04 = scala.collection.mutable.Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

1.2 获取值

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  // 1.获取指定 key 对应的值
  println(scores("hadoop"))

  // 2. 如果对应的值不存在则使用默认值
  println(scores.getOrElse("hadoop01", 100))
}

1.3 新增/修改/删除值

可变 Map 允许进行新增、修改、删除等操作。

object ScalaApp extends App {

  val scores = scala.collection.mutable.Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  // 1.如果 key 存在则更新
  scores("hadoop") = 100

  // 2.如果 key 不存在则新增
  scores("flink") = 40

  // 3.可以通过 += 来进行多个更新或新增操作
  scores += ("spark" -> 200, "hive" -> 50)

  // 4.可以通过 -= 来移除某个键和值
  scores -= "storm"

  for (elem <- scores) {println(elem)}
}

// 输出内容如下
(spark,200)
(hadoop,100)
(flink,40)
(hive,50)

不可变 Map 不允许进行新增、修改、删除等操作,但是允许由不可变 Map 产生新的 Map。

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  val newScores = scores + ("spark" -> 200, "hive" -> 50)

  for (elem <- scores) {println(elem)}

}

// 输出内容如下
(hadoop,10)
(spark,200)
(storm,30)
(hive,50)

1.4 遍历Map

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  // 1. 遍历键
  for (key <- scores.keys) { println(key) }

  // 2. 遍历值
  for (value <- scores.values) { println(value) }

  // 3. 遍历键值对
  for ((key, value) <- scores) { println(key + ":" + value) }

}

1.5 yield关键字

可以使用 yield 关键字从现有 Map 产生新的 Map。

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  // 1.将 scores 中所有的值扩大 10 倍
  val newScore = for ((key, value) <- scores) yield (key, value * 10)
  for (elem <- newScore) { println(elem) }


  // 2.将键和值互相调换
  val reversalScore: Map[Int, String] = for ((key, value) <- scores) yield (value, key)
  for (elem <- reversalScore) { println(elem) }

}

// 输出
(hadoop,100)
(spark,200)
(storm,300)

(10,hadoop)
(20,spark)
(30,storm)

1.6 其他Map结构

在使用 Map 时候,如果不指定,默认使用的是 HashMap,如果想要使用 TreeMap 或者 LinkedHashMap,则需要显式的指定。

object ScalaApp extends App {

  // 1.使用 TreeMap,按照键的字典序进行排序
  val scores01 = scala.collection.mutable.TreeMap("B" -> 20, "A" -> 10, "C" -> 30)
  for (elem <- scores01) {println(elem)}

  // 2.使用 LinkedHashMap,按照键值对的插入顺序进行排序
  val scores02 = scala.collection.mutable.LinkedHashMap("B" -> 20, "A" -> 10, "C" -> 30)
  for (elem <- scores02) {println(elem)}
}

// 输出
(A,10)
(B,20)
(C,30)

(B,20)
(A,10)
(C,30)

1.7 可选方法

object ScalaApp extends App {

  val scores = scala.collection.mutable.TreeMap("B" -> 20, "A" -> 10, "C" -> 30)

  // 1. 获取长度
  println(scores.size)

  // 2. 判断是否为空
  println(scores.isEmpty)

  // 3. 判断是否包含特定的 key
  println(scores.contains("A"))

}

1.8 与Java互操作

import java.util
import scala.collection.{JavaConverters, mutable}

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  // scala map 转 java map
  val javaMap: util.Map[String, Int] = JavaConverters.mapAsJavaMap(scores)

  // java map 转 scala map
  val scalaMap: mutable.Map[String, Int] = JavaConverters.mapAsScalaMap(javaMap)

  for (elem <- scalaMap) {println(elem)}
}

2. 元组(Tuple)

元组与数组类似,但是数组中所有的元素必须是同一种类型,而元组则可以包含不同类型的元素。

scala> val tuple=(1,3.24f,"scala")
tuple: (Int, Float, String) = (1,3.24,scala)

2.1 模式匹配

可以通过模式匹配来获取元组中的值并赋予对应的变量:

scala> val (a,b,c)=tuple
a: Int = 1
b: Float = 3.24
c: String = scala

如果某些位置不需要赋值,则可以使用下划线代替:

scala> val (a,_,_)=tuple
a: Int = 1

2.2 zip方法

object ScalaApp extends App {

   val array01 = Array("hadoop", "spark", "storm")
  val array02 = Array(10, 20, 30)

  // 1.zip 方法得到的是多个 tuple 组成的数组
  val tuples: Array[(String, Int)] = array01.zip(array02)
  // 2.也可以在 zip 后调用 toMap 方法转换为 Map
  val map: Map[String, Int] = array01.zip(array02).toMap

  for (elem <- tuples) { println(elem) }
  for (elem <- map) {println(elem)}
}

// 输出
(hadoop,10)
(spark,20)
(storm,30)

(hadoop,10)
(spark,20)
(storm,30)

3. 参考资料

  1. Martin Odersky . Scala 编程 (第 3 版)[M] . 电子工业出版社 . 2018-1-1

  2. 凯.S.霍斯特曼 . 快学 Scala(第 2 版)[M] . 电子工业出版社 . 2017-7

Map & Tuple