Scala--第三天

一、列表

　　定义：是Scala中一种重要的容器

　　特点：1.可以存储同类型的重复数据

　　　　　2.是有序的（可以进行索引操作，有先来后到之分）

　　分类：1.不可变列表：内容与长度均不可变

　　　　　 2.可变列表：内容元素与长度均可变

　　1.不可变列表

　　定义：

    //第一种方式：List关键字 常用
    var l1 = List(1, 2, 3, 4)
    println(l1)
    //    List(1, 2, 3, 4)
    //创建一个空列表
    var l2 = Nil
    println(l2)
    //    List()
    //第二种方式： :: 符号 不常用
    var l3 = 1 :: 2 :: Nil
    println(l3)
    //    List(1, 2)

　　2.可变列表

　　定义：需要先导入 ListBuffer

　import scala.collection.mutable.{ArrayBuffer, ListBuffer}

    // 定义带有初始化的可变列表
    var a = ListBuffer(1, 2, 3)
    println(a)
    //    ListBuffer(1, 2, 3)
    //定义一个空的可变列表
    var b = ListBuffer[Int]()
    println(b)
    //    ListBuffer()

    //使用 += 进行添加操作
    b += 1
    b += 2
    println(b)
    //ListBuffer(1, 2)

　　列表的常见操作

　　1.查看列表的长度与元素

    var a = List(1, 2, 3)
    var b = ListBuffer(2, 3, 4)
    //查看列表的长度
    println(a.length)
    println(b.length)
    //结果
    //3
    //3
    //查看列表元素
    println(a(0))
    println(b(0))
    //结果
    //1
    //2

　　2.列表的添加与删除 ###注意 ：只有可变的列表才有这些操作

    var a = List(1, 2, 3)
    var b = ListBuffer(2, 3, 4)
    //在可变列表后追加一个元素
    b += 5
    println(b)
    //结果
    //ListBuffer(2, 3, 4, 5)
    
    //在可变列表后，追加一个列表
    b ++= a
    println(b)
    //结果
    //ListBuffer(2, 3, 4, 5, 1, 2, 3)

    //可变列表删除指定的元素
    b -= 2
    println(b)
    //结果  从结果看出来  删除的是第一个符合条件的元素
    //ListBuffer(3, 4, 5, 1, 2, 3)

　　3.可变列表转为不可变列表，列表为空的判断

    var a = List(1, 2, 3)
    var b = ListBuffer(2, 3, 4)

    //可变列表转换成不可变列表
    var c = b.toList
    println(c)
    //结果
    //List(2, 3, 4)

    //判断列表是否为空
    println(c.isEmpty)
    //结果
    //false

　　4.列表的拼接

//俩个不可变列表进行拼接，产生新的不可变列表，源列表保持不变
    var a = List(1, 2, 3)
    var b = List(4, 5)
    var c = a ++ b
    println(c)
    println(a)
    println(b)
    //结果
    //List(1, 2, 3, 4, 5)
    //List(1, 2, 3)
    //List(4, 5)

    //俩个可变的列表进行拼接 产生了一个新的可变列表，源列表保持不变
    var d = ListBuffer(1, 2, 3)
    var e = ListBuffer(4, 5)
    var f = d ++ e
    println(f)
    println(d)
    println(e)
    //结果
    //ListBuffer(1, 2, 3, 4, 5)
    //ListBuffer(1, 2, 3)
    //ListBuffer(4, 5)

    //一个不可变 和一个可变列表进行拼接
    var x = List(1, 2, 3)
    var y = ListBuffer(4, 5, 6)
    var z1 = x ++ y
    var z2 = y ++ x
    println(z1)
    println(z2)
    //结果 最后的类型 由 拼接前者的类型决定
    //List(1, 2, 3, 4, 5, 6)
    //ListBuffer(4, 5, 6, 1, 2, 3)

　　5.其他常用操作

     var a = List(1,2,3,4)

      //取列表头和尾
      println(a.head)
      println(a.tail)
      //结果
      //1
      //List(2, 3, 4)
     
     //前缀，后缀 返回的依旧是列表
     println(a.take(3))
     println(a.drop(3))
     //结果
     //List(1, 2, 3)
     //List(4)　　　

　　6.扁平化/压平处理 （降维）

    var a = List(List(1, 2, 3), List(4, 5))
    var b= a.flatten
    println(b)
    //List(1, 2, 3, 4, 5)

　　7.拉链，拉开

    var a = List("ss", "vv")
    var b = List(1, 2)
    var c = a.zip(b)
    println(c)
    //结果 打包成一个由元组组成的列表
    //List((ss,1), (vv,2))

    //访问列表c的第一个元素的子元素
    println(c(0)._1)
    //结果
    //ss

    //解包
    var d =c.unzip
    println(d)
    //结果  解包成一个由列表组成的元组
    //(List(ss, vv),List(1, 2))

　　8.列表转字符串，拼接字符串（类似python中的join）

    //列表转字符串
    var a = List(1, 2, 3)
    println(a.toString)
    println(a.toString.getClass)
    //结果
    //List(1, 2, 3)
    //class java.lang.String
    
    //列表拼接字符串
    var b = a.mkString("-")
    println(b)
    //结果
    //1-2-3

　　9.并集，交集，差集

    var a = List(1, 2, 3, 4)
    var b = List(3, 4, 5, 6)
    
    //并集
    var c = a.union(b)
    println(c)
    //List(1, 2, 3, 4, 3, 4, 5, 6)
    
    //交集
    var d = a.intersect(b)
    println(d)
    //List(3, 4)
    
    //差集
    var e = a diff b
    println(e)
    //List(1, 2)

二、集合

　　特性：

　　　　1.元素不重复

　　　　2.无序

　　分类：

　　　　1.不可变集合

　　　　2.可变集合

　　注意：无论是不可变集合还是可变集合，都符合 集合俩个特性

　　1.不可变集合

　　　　定义

    //方式一：简单常用，会自动去重
    var s1 = Set(1, 2, 3, 4, 4)
    println(s1)
    //Set(1, 2, 3, 4)
    
    //方式二：注意()里面的是元素，而非集合的个数
    var s2 = Set[Int](1, 2)
    println(s2)
    //Set(1, 2)
    
    //空集合
    var s3 = Set()
    print(s3)
    //Set()

　　　　基本操作

    var s1 = Set(1, 2, 3, 4)
    //查看集合的长度
    println(s1.size)
    //4

    //遍历集合
    for (i <- s1) println(i)
    //1
    //2
    //3
    //4

    //删除集合的指定元素，原集合不变，生成一个新的集合
    var s2 = s1 - 1
    println(s1)
    //Set(1, 2, 3, 4)
    println(s2)
    //Set(2, 3, 4)

    //拼接 注意：保证俩个集合的类型相同
    var s3 = s1 ++ s2
    println(s3)
    //Set(1, 2, 3, 4)

    //集合和列表拼接，但是不能和元组拼接,因为元组不可变
    println(s1 ++ List(5, 6))
    //Set(5, 1, 6, 2, 3, 4)

    //集合 转list  无序变有序
    println(s1.toList)
    //List(1, 2, 3, 4)

　　2.可变集合

    //方式一：()里面的是元素
    var s1 = Set[Int](1, 2)
    println(s1)
    //Set(1, 2)
    //添加元素
    s1 += 3
    println(s1)
    //Set(1, 2, 3)
    //方式二：常用
    var s2 = Set(1, 2, 4, 5)
    println(s2)
    //Set(1, 5, 2, 4)

　　基本操作

    var s = Set(1, 2, 3, 4)
    s += 5
    println(s)
    s -= 1
    println(s)
    s ++= Set(6)
    println(s)
    //Set(1, 5, 2, 3, 4)
    //Set(5, 2, 3, 4)
    //Set(5, 2, 6, 3, 4)

三、映射Map

　　分类：不可变映射；可变映射

　　1.不可变映射

　　　　定义：

    //方式一
    var m1 = Map("k1" -> 1, "k2" -> 2)
    println(m1)
    //Map(k1 -> 1, k2 -> 2)

    //方式二
    var m2 = Map(("k1", "1"), ("k2", "2"))
    println(m2)
    //Map(k1 -> 1, k2 -> 2)

　　2.可变映射

　　　　定义方式与不可变相同，唯一的区别在于关键字需要导入

　　　　import scala.collection.mutable.Map

　　3.Map常规操作

    var m1 = Map(("k1", 1), ("k2", 2))
    //取值
    println(m1("k1"))
    //1

    //获取全部的key值 返回一个迭代器
    var a = m1.keys
    println(a)
    for (i <- a) println(i)
    //Set(k1, k2)
    //k1
    //k2

    //获取全部的value值，返回一个迭代器
    var b = m1.values
    println(b)
    //MapLike(1, 2)

    //遍历映射
    for ((k, v) <- m1) {
      println(s"${k}:${v}")
    }
    //k1:1
    //k2:2

    //取值 没有的话给一个默认值
    println(m1.getOrElse("k4", 4))
    //4

 　　4.Map添加元素，删除元素

    var m1 = Map(("k1", 1), ("k2", 2))
    //添加元素  元素 需要用（）括起来
    var m2 = m1 + ("k3" -> 3)
    m2.foreach(println(_))
    //删除元素 直接 - key值即可
    var m3 = m1 - "k1"
    println("-------")
    m3.foreach(println(_))
    //结果
    //(k2,2)
    //(k1,1)
    //(k3,3)
    //-------
    //(k2,2)