Scala List(列表)

Scala List(列表)

1、声明赋值

Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表具有递归的结构（也就是链接表结构）而数组不是。

列表的元素类型 T 可以写成 List[T]。

object Demo {
   def main(args: Array[String]) {
		// 字符串列表
		val strs: List[String] = List("I", "Love", "Scala")

		// 整型列表
		val nums: List[Int] = List(11, 22, 33, 44)

		// 空列表
		val empty: List[Nothing] = List()

		// 二维列表
		val dim: List[List[Int]] =
		   List(
			  List(1, 0, 0),
			  List(0, 1, 0),
			  List(0, 0, 1)
		   )
   }
}

构造列表的两个基本单位是 Nil 和 ::

Nil 也可以表示为一个空列表。

以上例子可以写成如下所示：

// 字符串列表
val strs = "I" :: ("Love" :: ("Scala" :: Nil))

// 整型列表
val nums = 11 :: (22 :: (33 :: (44 :: Nil)))

// 空列表
val empty = Nil

// 二维列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
          (0 :: (1 :: (0 :: Nil))) ::
          (0 :: (0 :: (1 :: Nil))) :: Nil

2、列表基本操作

Scala列表有三个基本操作：

• head 返回列表第一个元素
• tail 返回一个列表，包含除了第一元素之外的其他元素
• isEmpty 在列表为空时返回true

对于Scala列表的任何操作都可以使用这三个基本操作来表达。比如：

// 字符串列表
object Demo {
   def main(args: Array[String]) {
      val strs = "I" :: ("Love" :: ("Scala" :: Nil))
      val nums = Nil
      println( "第一个单词是 : " + strs.head )
      println( "除了第一个单词后是 : " + strs.tail )
      println( "查看列表 strs 是否为空 : " + strs.isEmpty )
      println( "查看 nums 是否为空 : " + strs.isEmpty )
   }
}

第一个单词是 : I
除了第一个单词后是 : List(Love, Scala)
查看列表 strs 是否为空 : false
查看 nums 是否为空 : false

3、连接列表

可以使用 ::: 运算符或 List.:::() 方法或 List.concat() 方法来连接两个或多个列表。实例如下：

object Demo {
  def main(args: Array[String]) {
      val str1 = "I" :: ("Love" :: ("Scala" :: Nil))
      val str2 = "Java" :: ("Bigdata" :: Nil)

      // 使用 ::: 运算符
      var newStr = str1 ::: str2
      println( "str1 ::: str2 : " + newStr )
     
      // 使用 List.:::() 方法
      newStr = str1.:::(str2)
      println( "str1.:::(str2) : " + newStr )

      // 使用 concat 方法
      newStr = List.concat(str1, str2)
      println( "List.concat(str1, str2) : " + newStr  )
   }
}

str1 ::: str2 : List(I, Love, Scala, Java, Bigdata)
str1.:::(str2) : List(Java, Bigdata, I, Love, Scala)
List.concat(str1, str2) : List(I, Love, Scala, Java, Bigdata)

4、List.fill()

使用 List.fill() 方法来创建一个指定重复数量的元素列表：

object Demo {
   def main(args: Array[String]) {
      val str = List.fill(8)("Scala") // 重复 Scala 8次
      println( "str : " + str  )

      val num = List.fill(10)(8)     // 重复元素 8, 10 次
      println( "num : " + num  )
   }
}

str : List(Scala, Scala, Scala, Scala, Scala, Scala, Scala, Scala)
num : List(8, 8, 8, 8, 8, 8, 8, 8, 8, 8)

5、List.tabulate()

List.tabulate() 方法是通过给定的函数来创建列表。

 

方法的第一个参数为元素的数量，可以是二维的，第二个参数为指定的函数，我们通过指定的函数计算结果并返回值插入到列表中，起始值为 0，比如：

object Demo {
  def main(args: Array[String]) {
    // 通过给定的函数创建 8 个元素
    val squares = List.tabulate(8)(n => n * n)
    println( "一维 : " + squares  )

    // 创建二维列表
    val mul = List.tabulate( 5,6 )( _ * _ )
    println( "多维 : " + mul  )
  }
}

一维 : List(0, 1, 4, 9, 16, 25, 36, 49)
多维 : List(List(0, 0, 0, 0, 0, 0), List(0, 1, 2, 3, 4, 5), List(0, 2, 4, 6, 8, 10), List(0, 3, 6, 9, 12, 15), List(0, 4, 8, 12, 16, 20))

6、List.reverse

用于将列表的顺序反转，比如：

object Demo {
  def main(args: Array[String]) {
    val str = "I" :: ("Love" :: ("Scala" :: Nil))
    println( "str 反转前 : " + str )
    println( "str 反转后 : " + str.reverse )
  }
}

str 反转前 : List(I, Love, Scala)
str 反转后 : List(Scala, Love, I)

7、Scala List 常用方法

1	def +:(elem: A): List[A] 为列表预添加元素 scala> val x = List(1) x: List[Int] = List(1) scala> val y = 2 +: x y: List[Int] = List(2, 1) scala> println(x) List(1)
2	def ::(x: A): List[A] 在列表开头添加元素
3	def :::(prefix: List[A]): List[A] 在列表开头添加指定列表的元素
4	def :+(elem: A): List[A] 复制添加元素后列表。 scala> val a = List(1) a: List[Int] = List(1) scala> val b = a :+ 2 b: List[Int] = List(1, 2) scala> println(a) List(1)
5	def addString(b: StringBuilder): StringBuilder 将列表的所有元素添加到 StringBuilder
6	def addString(b: StringBuilder, sep: String): StringBuilder 将列表的所有元素添加到 StringBuilder，并指定分隔符
7	def apply(n: Int): A 通过列表索引获取元素
8	def contains(elem: Any): Boolean 检测列表中是否包含指定的元素
9	def copyToArray(xs: Array[A], start: Int, len: Int): Unit 将列表的元素复制到数组中。
10	def distinct: List[A] 去除列表的重复元素，并返回新列表
11	def drop(n: Int): List[A] 丢弃前n个元素，并返回新列表
12	def dropRight(n: Int): List[A] 丢弃最后n个元素，并返回新列表
13	def dropWhile(p: (A) => Boolean): List[A] 从左向右丢弃元素，直到条件p不成立
14	def endsWith[B](that: Seq[B]): Boolean 检测列表是否以指定序列结尾
15	def equals(that: Any): Boolean 判断是否相等
16	def exists(p: (A) => Boolean): Boolean 判断列表中指定条件的元素是否存在。 判断l是否存在某个元素: scala> l.exists(s => s == "Hah") res7: Boolean = true
17	def filter(p: (A) => Boolean): List[A] 输出符号指定条件的所有元素。 过滤出长度为3的元素: scala> l.filter(s => s.length == 3) res8: List[String] = List(Hah, WOW)
18	def forall(p: (A) => Boolean): Boolean 检测所有元素。 例如：判断所有元素是否以"H"开头： scala> l.forall(s => s.startsWith("H")) res10: Boolean = false
19	def foreach(f: (A) => Unit): Unit 将函数应用到列表的所有元素
20	def head: A 获取列表的第一个元素
21	def indexOf(elem: A, from: Int): Int 从指定位置 from 开始查找元素第一次出现的位置
22	def init: List[A] 返回所有元素，除了最后一个
23	def intersect(that: Seq[A]): List[A] 计算多个集合的交集
24	def isEmpty: Boolean 检测列表是否为空
25	def iterator: Iterator[A] 创建一个新的迭代器来迭代元素
26	def last: A 返回最后一个元素
27	def lastIndexOf(elem: A, end: Int): Int 在指定的位置 end 开始查找元素最后出现的位置
28	def length: Int 返回列表长度
29	def map[B](f: (A) => B): List[B] 通过给定的方法将所有元素重新计算
30	def max: A 查找最大元素
31	def min: A 查找最小元素
32	def mkString: String 列表所有元素作为字符串显示
33	def mkString(sep: String): String 使用分隔符将列表所有元素作为字符串显示
34	def reverse: List[A] 列表反转
35	def sorted[B >: A]: List[A] 列表排序
36	def startsWith[B](that: Seq[B], offset: Int): Boolean 检测列表在指定位置是否包含指定序列
37	def sum: A 计算集合元素之和
38	def tail: List[A] 返回所有元素，除了第一个
39	def take(n: Int): List[A] 提取列表的前n个元素
40	def takeRight(n: Int): List[A] 提取列表的后n个元素
41	def toArray: Array[A] 列表转换为数组
42	def toBuffer[B >: A]: Buffer[B] 返回缓冲区，包含了列表的所有元素
43	def toMap[T, U]: Map[T, U] List 转换为 Map
44	def toSeq: Seq[A] List 转换为 Seq
45	def toSet[B >: A]: Set[B] List 转换为 Set
46	def toString(): String 列表转换为字符串

下面展示了部分方法的使用：

 

object Demo {
  def main(args: Array[String]) {
    //1、
    // def +:(elem: A): List[A]
    //为列表预添加元素
    val x = List(1)
    val y = 2 +: x
    println(x)
    println(y)
    //2、
    // def ::(x: A): List[A]
    //在列表开头添加元素
    val a = List(11)
    val b = a.::(21)
    println(a)
    println(b)
    //3、
    // def :::(prefix: List[A]): List[A]
    //在列表开头添加指定列表的元素
    val aa = List(11)
    val bb = aa.:::(List(1,2,3,4))
    println(aa)
    println(bb)
    //4、
    // def :+(elem: A): List[A]
    //复制添加元素后列表。
    val c = List(4)
    val d = c :+List(44)
    println(c)
    println(d)
    //5、
    //def addString(b: StringBuilder): StringBuilder
    //将列表的所有元素添加到 StringBuilder
    val e = List(5,4,6)
    val sb = new StringBuilder()
    val f = e.addString(sb)
    println(sb)
    println(f)
    //6、
    // def addString(b: StringBuilder, sep: String): StringBuilder
    //将列表的所有元素添加到 StringBuilder，并指定分隔符
    val a1 = List(5,4,6)
    val b1 = new StringBuilder()
    val f1 = a1.addString(b1,",")
    println(f1)
    println(b1)
    //7、
    // def apply(n: Int): A
    //通过列表索引获取元素
    val a11 = List(5,4,6)
    val f11 = a11.apply(2)
    println(f11)
    //8、
    //def contains(elem: Any): Boolean
    //检测列表中是否包含指定的元素
    val a12 = List(5,4,6)
    println( a12.contains(4))
    //9、
    //def copyToArray(xs: Array[A], start: Int, len: Int): Unit
    //将列表的元素复制到数组中。
    val a13 = List(1,2,3,4,5,6,7,8)
    var z:Array[Int] = new Array[Int](8)
    a13.copyToArray(z)
    for (i <- z){
      println(z.toString)
    }
    //10、
    // def distinct: List[A]
    //去除列表的重复元素，并返回新列表
    val a14 = List(1,2,2,4,4,6,7,8)
    val b14= a14.distinct
    println(b14)
    //11、
    //def drop(n: Int): List[A]
    //
    //丢弃前n个元素，并返回新列表
    val a15 = List(1,2,2,4,4,6,7,8)
    val b15= a15.drop(2)
    println(a15)
    println(b15)
    //12、def dropRight(n: Int): List[A]
    //
    //丢弃最后n个元素，并返回新列表
    val a16 = List(1,2,2,4,4,6,7,8)
    val b16= a16.dropRight(2)
    println(a16)
    println(b16)
    //13、def dropWhile(p: (A) => Boolean): List[A]
    //
    //从左向右丢弃元素，直到条件p不成立
    val a17 = List("hhh","gggg","llll")
    val b17 = a17.dropWhile(s => s.length == 3)
    println(b17)

    val a18 = List(1,2,2,4,4,6,7,8)
    println(a18.init)
    //后续省略，可自模拟剩下方法的用法

  }
}

List(1)
List(2, 1)
List(11)
List(21, 11)
List(11)
List(1, 2, 3, 4, 11)
List(4)
List(4, List(44))
546
546
5,4,6
5,4,6
6
true
[I@880ec60
[I@880ec60
[I@880ec60
[I@880ec60
[I@880ec60
[I@880ec60
[I@880ec60
[I@880ec60
List(1, 2, 4, 6, 7, 8)
List(1, 2, 2, 4, 4, 6, 7, 8)
List(2, 4, 4, 6, 7, 8)
List(1, 2, 2, 4, 4, 6, 7, 8)
List(1, 2, 2, 4, 4, 6)
List(gggg, llll)
List(1, 2, 2, 4, 4, 6, 7)