def main(args: Array[String]) {
// 字符串列表
val language: List[String] = List("java",
"python", "c++")
// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)
// 空列表
val empty: List[Nothing] = List()
// 二维列表
val dim: List[List[Int]] =
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1))
}
def main(args: Array[String]) {
// 字符串列表
val language= "java" :: ("python" :: ("c++" :: Nil))
// 整型列表
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
// 空列表
val empty = Nil
// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
(0 :: (1 :: (0 :: Nil))) ::
(0 :: (0 :: (1 :: Nil))) :: Nil
object TestListFunction {
def main(args: Array[String]) {
val language1 = "java" :: ("python" :: ("c++" ::
Nil))
val nums = Nil
/**
* 基本操作
*/
println("基本操作--------");
println("第一语言是 : " + language1.head)
println("除第 1 个语言之外的其它语言是 : " +
language1.tail)
println("查看列表 site 是否为空 : " +
language1.isEmpty)
println("查看 nums 是否为空 : " + nums.isEmpty)
/**
* 列表连接
*/
println("列表连接--------");
val language2 = "c" :: ("php" :: ("go" :: Nil))
// 使用 ::: 运算符
var mainLanguages = language1 ::: language2
println("language1 ::: language2 : " + mainLanguages)
// 使用 List.:::() 方法
mainLanguages = language1.:::(language2)
println("language1.:::(language2) : " + mainLanguages)
// 使用 concat 方法
mainLanguages = List.concat(language1, language2)
println("List.concat(language1, language2) : " +
mainLanguages)
/**
* fill 填充列表的重复元素
*/
println("List fill--------");
val bestLanguage = List.fill(3)("php") // 重复 Runoob
3 次
println("bestLanguage : " + bestLanguage)
val num = List.fill(10)("php") // 重复元素 "php", 10 次
println("num : " + num)
/**
* List tabulate 通过给定的函数来创建列表
*/
println("List tabulate--------");
// 通过给定的函数创建 6 个元素
val squares = List.tabulate(6)(n => n * n)
println("一维 : " + squares)
// 创建二维列表
val mul = List.tabulate(4, 5)(_ * _)
println("多维 : " + mul)
/**
* List.reverse 用于将列表的顺序反转
*/
println("List.reverse--------");
println(mainLanguages.reverse);
} }
Scala Set(集合) o 概念说明
没有重复的对象集合,所有的元素都是唯一的
Set 集合分为可变的和不可变的集合
默认使用不可变集合,完整类路径为:
scala.collection.immutable.Set
若要引用可变集合类型,则类路径为:
scala.collection.mutable.Set
o 基础应用示例
不可变集合使用
def main(args: Array[String]): Unit = {
//初始化 set 集合
val set = Set(1, 2, 3, 4, 5, 6)
//得到对应的 set 路径
println(set.getClass.getName)
//利用 exists 方法,判断集合元素中是否存在%2==0 的元素
println(set.exists(_ % 2 == 0))
//打印当前集合序列
println(set) } 可变集合使用
def main(args: Array[String]): Unit = {
//初始化 set 集合
val mutableSet = Set(1, 2, 3, 4, 5, 6)
//获取可变集合的 set 路径
println(mutableSet.getClass.getName)
//添加元素
mutableSet.add(4)
println("添加元素 4 后="+mutableSet)
//删除元素
mutableSet.remove(1)
println("删除元素 1 后="+mutableSet)
mutableSet += 7
println("+7 后"+mutableSet)
mutableSet -= 2
println("-2 后"+mutableSet)
//将可变 set 转换成不可变 set
val another = mutableSet.toSet
println(another.getClass.getName) //
scala.collection.immutable.Set
}
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) }