Scala collections

def main(args: Array[String]): Unit = {
val languageSet1 = Set("java", "python", "c++")
val numSet: Set[Int] = Set()
/**
* 基本操作
*/
println("基本操作--------");
println("第一语言是 : " + languageSet1.head)
println("除第 1 Languages ​​other than this language are : " +
languageSet1.tail)
println("查看列表 site 是否为空 : " +
languageSet1.isEmpty)
println("查看 nums 是否为空 : " + numSet.isEmpty)
/**
* Collection join operation
*/
println("集合连接--------");
val languageSet2 = Set("c", "php", "go")
// ++ use as an operator
var mainlanguageSet = languageSet1 ++ languageSet2
println("languageSet1 ++ languageSet2 : " +
mainlanguageSet)
// ++ 作为方法使用
mainlanguageSet = languageSet1.++(languageSet2)
println("languageSet1.++(languageSet2) : " +
mainlanguageSet)
/**
* Find the largest set、最小元素
*/
println("Find the largest and smallest elements of a set--------");
println("mainlanguageSet The smallest element in the set is : " +
mainlanguageSet.min)
println("mainlanguageSet The largest element in the set is : " +
mainlanguageSet.max)
/**
* 求交集
*/
println("求集合的交集--------")
var secondLanguageSet=Set("shell","perl","java")
println("mainlanguageSet.&(secondLanguageSet) : " +
mainlanguageSet.&(secondLanguageSet))
println("mainlanguageSet.intersect(secondLanguageSet) 
: " + mainlanguageSet.intersect(secondLanguageSet))
}

Scala Map(映射) o 概念说明
 一种可迭代的键值对（key/value）结构,也称为哈希表
 所有的值都可以通过键来获取,键值是唯一的
 两种类型,可变与不可变,The difference is that mutable objects can be modified
它,而不可变对象不可以
 默认使用的不可变 Map,可变的 Map 需要使用 import 
scala.collection.mutable.Map 类 o 基础示例

def main(args: Array[String]): Unit = {
// Immutable null Map,键为字符串,值为整型
var personMap: Map[String, String] = Map()
// Immutable initialization
val languageMap = Map("java" -> "java 程序设计",
"python" -> "python 程序设计", "c++" -> "c++程序设计")
//dynamic to immutable map 中添加值
personMap += ("001" -> "张三")
//languageMap += ("java" -> "It's new") //此处会报错
println(personMap)
println(languageMap)
//Initialize mutable Map
val languageMap2 = scala.collection.mutable.Map("java"
-> "java 程序设计", "python" -> "python 程序设计", "c++" ->
"c++程序设计")
//variable Map 中添加值
languageMap2.put("python","已经更新了")
println(languageMap2) }

关于不可变和可变 Map 的总结
o 不可变 Map
 api 不太丰富
 如果是 var 修饰,引用可变,支持读写
 如果是 val 修饰,引用不可变,只能写入一次值,其后只读

o 可变 Map
 api 丰富与 Java 中 Map 基本类似
 如果是 var 修饰,引用可变,支持读写
 如果是 val 修饰,引用不可变,支持读写
o 总结
 可变与不可变,主要是通过 val 和 var 来限定达到意图
 api 丰富程度不一样
 常用操作
o keys：返回 Map 所有的键(key)
o values：返回 Map 所有的值(value)
o isEmpty：在 Map 为空时返回 true
o 使用++运算符或 Map.++()方法来连接两个 Map,Map move when merging
except duplicates key. o 通过 foreach 循环输出 Map 中的 keys 和 values： o 使用 Map.contains 方法来查看 Map 中是否存在指定的 Key
 综合示例

def main(args: Array[String]): Unit = {
// Immutable null Map,键为字符串,值为整型
var personMap: Map[String, String] = Map()
// Immutable initialization
val languageMap = Map("java" -> "java 程序设计",
"python" -> "python 程序设计", "c++" -> "c++程序设计")
/**
* 基础操作
*/
println("基础操作---------")
println("languageMap 中的键为 : " + languageMap.keys)
println("languageMap 中的值为 : " +
languageMap.values)
println("检测 languageMap 是否为空:" +
languageMap.isEmpty)
println("检测 personMap 是否为空: " +
personMap.isEmpty)
/**
* map 合并
*/
println(" map 合并---------")
val languageMap2 = Map("C" -> "C 程序设计")
// ++ 作为运算符
var mainLanguages = languageMap ++ languageMap2
println("languageMap ++ languageMap2 : " +
mainLanguages)
// ++ 作为方法
mainLanguages = languageMap.++(languageMap2)
println("languageMap.++(languageMap2)) : " +
mainLanguages)
/**
* map 的 keys 和 values 输出
*/
println("map 的 keys 和 values 输出---------")
mainLanguages.keys.foreach { i =>
print("Key = " + i)
println(" Value = " + mainLanguages(i))
}
/**
* 查看 Map 中是否存在指定的 Key
*/
println("查看 Map 中是否存在指定的 Key---------")
if (mainLanguages.contains("java")) {
println("java 键存在,对应的值为 :" +
mainLanguages("java"))
} else {
println("java 键不存在") }
if (mainLanguages.contains("c#")) {
println("java 键存在,对应的值为 :" +
mainLanguages("c#"))
} else {
println("c#键不存在") } }

def main(args: Array[String]): Unit = {
//直接定义元组
var personInfo = ("s0001", "张三", 21, "河北科技大学", 1.80)
//通过 TupleN 来定义,N 可以是 1 至 22 optional number of tuples
var pessonInfoTuple5 = new Tuple5("s0001", "张三", 21, "河北科技大学",
1.80);
/**
* 元组访问,Access by index subscript of tuple,从 1 开始,元组对象._1 代表第 1 个元素,
元组对象._2 代表第 2 个元素,
*/
println("元组访问---------");
println("学号=" + personInfo._1);
println("姓名=" + personInfo._2);
println("年龄=" + personInfo._3);
println("学校=" + personInfo._4);
println("身高=" + personInfo._5);
/**
* 元组遍历
*/
println("元组遍历---------");
personInfo.productIterator.foreach { i => println("元素值 = " + i) }
/**
* 元组转换成字符串
*/
println("元组转换成字符串 ---------");
println(personInfo.toString())
}

def main(args: Array[String]): Unit = {
//定义一个 map 对象
val mainLanguagesMap = Map("java" -> "java 程序设计",
"python" -> "python 程序设计")
//By specifying the key value,get possible value,其返回值是一个
Option[T],Indicates that there may be a corresponding key value value,也有可能不存在
var javaDesc: Option[String] =
mainLanguagesMap.get("java");
var phpDesc: Option[String] =
mainLanguagesMap.get("php");
//print the result
println("mainLanguagesMap.get(\"java\") : " +
javaDesc)
println("mainLanguagesMap.get(\"php\") : " +
phpDesc)
//Determine whether the result has value,即是否为 None
println("javaDesc.isEmpty: " + javaDesc.isEmpty)
println("phpDesc.isEmpty: " + phpDesc.isEmpty)
//do the result getOrElse 操作,That is, if there is no such key,则取
方法的默认值
println("mainLanguagesMap.get(\"java\") : " +
javaDesc.getOrElse("没有拿到 java 的描述信息"))
println("mainLanguagesMap.get(\"php\") : " +
phpDesc.getOrElse("没有拿到 php 的描述信息"))
}

def main(args: Array[String]): Unit = {
val it1 = Iterator("java", "python", "c++")
val it2 = Iterator("java", "python", "c++")
val it3 = Iterator("java", "python", "c++")
val it4 = Iterator("java", "python", "c++")
val it5 = Iterator("java", "python", "c++")
/**
* 迭代器遍历集合
*/
println("遍历集合---------");
while (it1.hasNext) {
println(it1.next())
}
/**
* Iterator to find the maximum value of a collection
*/
println("Find the maximum value of an iterator collection---------");
println(it2.max)
/**
* Iterator to find the minimum value of a collection
*/
println("Find the minimum value of an iterator set---------");
println(it3.min)
/**
* Iterator to find length of collection
*/
println("Iterator to find length of collection---------");
println(it4.size)
println(it5.length) }