博客

Scala中的List为有序可重复的集合，List为不可变列表，可变列表为ListBuffer。

Scala中List类为什么不支持添加（append）操作？

List类没有提供append操作，因为随着列表的变长，append的耗时将呈线性增长，而使用::做前缀则仅耗用固定的时间。如果要对List进行添加元素操作，建议使用ListBuffer，一种提供append操作的可变列表，完成之后再调用toList。

package com.fuyun.bigdata.scala.collection

import scala.collection.mutable.ListBuffer

/**
  *  List有序可重复集合：列表List基本使用
  */
object ListDemo {

  def main(args: Array[String]): Unit = {
    // 创建空列表
    val list = Nil
    println(s"list : ${list.mkString(", ")}")
    // 创建不可变的列表list
    val list1 = List(3, 6, 8, 9)
    /*
     * 在scala中list的组成
     *   list = head(element) + tail(是一个list，除了头部元素以外的其他组成的list集合)
     */
    println(s"list1 head is :${list1.head}")
    println(s"list1 tail is :${list1.tail}")
    println(s"list element top three is:${list1.sorted.reverse.take(3)}")
    println(s"list1 init is :${list1.init}") //返回list1列表除最后一个元素外组成的新列表
    println(s"list1 last is :${list1.last}")//返回list1列表最后一个元素
    // TODO: 如果list只有一个元素，head为元素，tail为空集合 List()/Nil
    val list2 = List(66)
    println(s"list2 head is :${list2.head}")
    println(s"list2 tail is :${list1.tail}") // 空的集合，可使用Nil表示


    // list的第二种创建方式
    /*
     * TODO -> 1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3)
     *
     */
    /*
     * 下面的运算从右到左
     * 首先是头部为1，尾部为空列表的列表
     * 然后将这个列表作为尾部，头部为2组成新列表
     * 最后结果为List(2, 1)
     */
    val list3 = 2::1::Nil
    println(list3.mkString(", "))
    println(s"list1 + list2 is :${list1:::list2}")//将list1和list2两个列表合并组成新的列表

    /*
     * 可变的list：ListBuffer，类似可变的ArrayBuffer
     * 记得导包
     */
    import scala.collection.mutable
    // 创建ListBuffer实例对象
    val listBuffer = ListBuffer[Int]()
    // 向可变的listBuffer中添加
    listBuffer += 1
    listBuffer += 3

    // ++=方法用于添加列表中每个元素
    listBuffer ++= List(6, 8)
    // 添加元组
    listBuffer += (5, 9, 6)

    // 同样，如果对可变的list集合进行操作，建议将其转换为不可变的list列表
    val list4 = listBuffer.toList
    println(list4.mkString("< ", ", ", " >"))

    // 判断是否为空
    println(list4.isEmpty)
    // 判断某个元素是否在列表中
    println(list4.contains(6))
    // 以反序方式从数组末尾到数组头遍历元素
    println(list4.reverse(3)) // 从末尾数第4个元素
    println(list4.reverse) // 反序输出列表
    // 对列表进行去重
    println(list4.distinct)
    // 第1到第3个元素
    println(list4.slice(0, 3))
    list4.count(e => e == 3) //计算元素为3的个数
    println(list4.drop(2))//返回去掉前两个的list

    val listList = List("hadoop, spark, scala, python, java", "hive, mysql, hadoop", "php, hbase")
    val xx: List[Array[String]] = listList.map(_.split(", "))
    val xxx = xx.map(arr => arr(0))
    println(xxx)
    //println(listList.map(_.split(", ")))
    println(listList.flatMap(_.split(". ")))
  }

}

运行结果：

list :

list1 head is :3

list1 tail is :List(6, 8, 9)

list element top three is:List(9, 8, 6)

list2 head is :66

list2 tail is :List()

2, 1

< 1, 3, 6, 8, 5, 9, 6 >

false

true

8

List(6, 9, 5, 8, 6, 3, 1)

List(1, 3, 6, 8, 5, 9)

List(1, 3, 6)

Process finished with exit code 0