共计 3443 个字符，预计需要花费 9 分钟才能阅读完成。
// 对于共享雷同类型的不可变对象序列，能够应用 Scala 的 List 类
// 作为一个 array，一个 list[String] 蕴含为 String 类型，scala 中的 list 和 java 中的 list 不一样
//scala 中的 list 是不可变得
val oneTwoThree = List(1,2,3) // 相当于定义了一个 List[Int] 的 list，外面的元素为 Int 类型
println(oneTwoThree + ” this is a List”)
// 列表是不可变的，它们的行为有点像 Java 字符串: 当您调用一个列表上的办法时，
// 该办法的名称可能暗示该列表将发生变化，但它会创立并返回一个具备新值的新列表。
// 例如，List 有一个名为::: 的办法用于列表连贯
val list1 = List(1,2)
val list2 = List(3,4)
val list1AndList2 = list1 ::: list2
println(“one list1″ + list1 + ” and two list2 ” + list2)
println(“used ::: 连贯两个 list：” + list1AndList2)
// 兴许大家大数据培训学习中在列表中应用的最常见的操作符是::，它发音为 cons。cons 将一个新元素放在现有列表的结尾，并返回后果列表
val consBeforeList = List(2,3)
val consAfterList = 1 :: consBeforeList
println(“consBeforeList : ” + consBeforeList)
println(“consAfterList : ” + consAfterList)
// 这里不须要应用 new List，应为 List.apply() 被定义在 scala.List 这个对象中，是一个工厂办法
//:: 是一个右操作数的办法
// 您可能狐疑:: method 的关联性存在一些问题，
// 但它实际上是一个须要记住的简略规定：如果在运算符表示法中应用了一个办法，
// 例如 b，则在左操作数上调用该办法，如 在 a.(b) 中 – 办法名称以冒号结尾。
// 如果办法名称以冒号结尾，则在右操作数上调用该办法。
// 因而，在 1 :: consBeforeList 中，:: method 被调用在 consBeforeList 上，传入 1，就像这样：consBeforeList. :: (1)
// 制订一个空的 list 是应用 nil，一种是创立蕴含中有的 list，用 cons 操作进行追加一个 nil 元素到最初
val nilList = 1 :: 2 :: 3 :: Nil
println(“this is a nil append last:” + nilList)
//list 的所有操作
val createNilList = List()
val createNilListT = Nil // 或者创立的时候间接赋值为 Nil
println(“ 创立一个空的 list：” + createNilList)
// 创立有内容的 list
val hasContentList = List(“tony”,”hello”,”shanghai”)
println(“ 默认有内容的 list：” + hasContentList)
// 创立的有内容的另一种形式, 已这种前面必须要追加一个 Nil
val hasContentList2 = “tony” :: “hello” :: “shanghai” :: Nil
println(“ 创立有内容的 list 通过::” + hasContentList2)
// 将两个 list 合并
val listOne = List(“one”,”two”)
val listTwo = List(“three”,”four”)
val listInner = listOne ::: listTwo
println(“ 通过::: 合并两个 list：” + (listOne ::: listTwo))
println(“ 合并后的 listInner：” + listInner)
// 取出 list 中相应下标的值，下标从 0 开始计算
println(“ 取出 listOne 第二个元素：” + listOne(1))
println(“ 应用 count 办法（返回元素中数组长度为 4 的元素下标 +1）：” + listInner.count(liststr => liststr.length == 4))
// 返回取出 N 个之后的数据
println(“ 返回取出 2 个之后的 list 的元素：” + listInner.drop(2))
// 显示 list 中 list.length- n 的元素，就是除去倒数 n 个元素的 list
println(“ 除去倒数 n 个元素的 list:” + listInner.dropRight(2))
// 查看一个元素在 list 中是否存在, 返回 false 或者 true
println(“ 查看一个元素在 list 中是否存在:” + listInner.exists(liststr => liststr == “tony”))
// 过滤相干的元素
println(“ 过滤相干的元素:” + listInner.filter(liststr => liststr.length == 3))
// 查看 list 中所有的元素的条件，这里已完结字符判断，返回 false 或者 true
println(“ 查看 list 中所有的元素的条件，所有元素以 o 完结:” + listInner.forall(liststr => liststr.endsWith(“o”)))
// 打印所有的 list 中的元素
listInner.foreach(liststr => print(liststr + ” “))
// 打印所有的 list 中的元素的简写形式
listInner.foreach(print)
// 返回 list 中的第一个元素
println(“ 返回 list 中的第一个元素：” + listInner.head)
// 返回 list 中元素，不包含最初一个元素
println(“ 返回 list 中的所有元素，不包含最初一个：” + listInner.init)
// 判断 list 是否为空
println(“ 判断 list 是否为空：” + listInner.isEmpty)
// 返回 list 中的最初一个元素
println(“ 返回 list 中最初一个元素：” + listInner.last)
// 返回 list 的长度
println(“ 返回 list 的长度信息：” + listInner.length)
// 将 list 中所有的元素的值前面追加一个字符
println(“ 将 list 中所有的元素的值前面追加一个字符:” + listInner.map(liststr => liststr + “l”))
// 将 list 中元素作为字符串返回，并与相干字符拼接
println(“ 将 list 中元素作为字符串返回，并与相干字符拼接:” + listInner.mkString(“.”))
//list 中移除相干的元素
println(“listInner:” + listInner)
// val listRemove = listInner.remove(liststr => liststr.length == 4)
// println(“list 中移除相干的元素:” + listRemove)
// 这里的 remove 会报错，在以后这个版本曾经一处掉了，自从 2.9.0 之后，当初咱们应用 filterNot 这个
println(“list 中移除相干的元素:” + listInner.filterNot(liststr => liststr.length == 4))
// 将 list 中的元素进行翻转
println(“ 将 list 中的元素进行翻转：” + listInner.reverse)
// 将 list 中的元素进行排序，sort 在我以后这个版本曾经移除了，自从 2.9.0 之后，变为了 sortWith
// val sortList = listInner.sort((str,t) => str.charAt(0).toLower < t.charAt(0).toLower)
// println(“ 将 list 中的元素进行排序之后的 list：” + sortList)
val sortList = listInner.sortWith((str,t) => str.charAt(0).toLower < t.charAt(0).toLower)
println(“ 将 list 中的元素进行排序之后的 list：” + sortList)
// 显示 list 中的所有的元素，减去第一个
println(“ 显示 list 中的所有的元素，减去第一个:” + listInner.tail)