scala集合

def main(args: Array[String]): Unit = {
val languageSet1 = Set("java", "python", "c++")
val numSet: Set[Int] = Set()
/**
* 基本操作
*/
println("基本操作--------");
println("第一语言是 : " + languageSet1.head)
println("除第 1 个语言之外的其它语言是 : " +
languageSet1.tail)
println("查看列表 site 是否为空 : " +
languageSet1.isEmpty)
println("查看 nums 是否为空 : " + numSet.isEmpty)
/**
* 集合连接操作
*/
println("集合连接--------");
val languageSet2 = Set("c", "php", "go")
// ++ 作为运算符使用
var mainlanguageSet = languageSet1 ++ languageSet2
println("languageSet1 ++ languageSet2 : " +
mainlanguageSet)
// ++ 作为方法使用
mainlanguageSet = languageSet1.++(languageSet2)
println("languageSet1.++(languageSet2) : " +
mainlanguageSet)
/**
* 求集合最大、最小元素
*/
println("求集合最大和最小元素--------");
println("mainlanguageSet 集合中的最小元素是 : " +
mainlanguageSet.min)
println("mainlanguageSet 集合中的最大元素是 : " +
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）结构，也称为哈希表
 所有的值都可以通过键来获取，键值是唯一的
 两种类型，可变与不可变，区别在于可变对象可以修改
它，而不可变对象不可以
 默认使用的不可变 Map，可变的 Map 需要使用 import 
scala.collection.mutable.Map 类 o 基础示例

def main(args: Array[String]): Unit = {
// 不可变空 Map，键为字符串，值为整型
var personMap: Map[String, String] = Map()
// 不可变初始化
val languageMap = Map("java" -> "java 程序设计",
"python" -> "python 程序设计", "c++" -> "c++程序设计")
//动态向不可变 map 中添加值
personMap += ("001" -> "张三")
//languageMap += ("java" -> "已经理新了") //此处会报错
println(personMap)
println(languageMap)
//初始化可变 Map
val languageMap2 = scala.collection.mutable.Map("java"
-> "java 程序设计", "python" -> "python 程序设计", "c++" ->
"c++程序设计")
//向可变 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 合并时会移
除重复的 key。 o 通过 foreach 循环输出 Map 中的 keys 和 values： o 使用 Map.contains 方法来查看 Map 中是否存在指定的 Key
 综合示例

def main(args: Array[String]): Unit = {
// 不可变空 Map，键为字符串，值为整型
var personMap: Map[String, String] = Map()
// 不可变初始化
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 个可选的元组个数
var pessonInfoTuple5 = new Tuple5("s0001", "张三", 21, "河北科技大学",
1.80);
/**
* 元组访问，通过元组的索引下标访问，从 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 程序设计")
//通过指定键值，获取可能的 value，其返回值是一个
Option[T]，代表有可能会存在该键值对应的 value，也有可能不存在
var javaDesc: Option[String] =
mainLanguagesMap.get("java");
var phpDesc: Option[String] =
mainLanguagesMap.get("php");
//打印拿到的结果
println("mainLanguagesMap.get(\"java\") : " +
javaDesc)
println("mainLanguagesMap.get(\"php\") : " +
phpDesc)
//判断结果是否有值，即是否为 None
println("javaDesc.isEmpty: " + javaDesc.isEmpty)
println("phpDesc.isEmpty: " + phpDesc.isEmpty)
//对拿到的结果做 getOrElse 操作，即如果不存在该 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())
}
/**
* 迭代器求集合的最大值
*/
println("求迭代器集合的最大值---------");
println(it2.max)
/**
* 迭代器求集合的最小值
*/
println("求迭代器集合的最小值---------");
println(it3.min)
/**
* 迭代器求集合的长度
*/
println("迭代器求集合的长度---------");
println(it4.size)
println(it5.length) }