Scala集合

map

里面存放的键值对，且键唯一。

package ScalaStudy_day02

import scala.collection.immutable.HashMap
import scala.collection.mutable

object MapDemo {

  def main(args: Array[String]): Unit = {

    // 创建map
    // 不可变的map   immutable map
    val scoreMap = Map("刘恩奇"->90,"唐门"->80)

    // 通过元祖的形式定义一个map
    val scoreMap1 = Map(("zhangsan",90),("lisi",80),("wangwu",70))

    // 构建一个可变的map
    val scoreMap2 = scala.collection.mutable.Map(("zhangsan",90),("lisi",80),("wangwu",70))

    // 访问内部键值对数据
    val res = scoreMap("刘恩奇")   // 如果该键不存在 就会报异常
    println(res)

    //    val res1 = scoreMap("asdad")
    //    println(res1) // Exception in thread "main" java.util.NoSuchElementException: key not found:

   // 如何避免异常----> 先判断一下是否包含该键
    val res2 = if (scoreMap.contains("zhangsan")) scoreMap("zhangsan") else 0

    // 推荐方法 // 传入对应键参数   传入失败返回值参数
    val res3 = scoreMap.getOrElse("张三", 0)

    println(res3)

    // 修改可变的map信息
    // 修改键对应的值
    scoreMap2("lisi") = 1000
    scoreMap2.update("lisi", 60)


    // 如果键存在，修改相应键的值，如果不存在，增加新的键值对
    scoreMap2("tom") = 120

    // 添加新的键值对
    scoreMap2 += ("jerry"->100)

    // 追加一个集合的元素到集合里
    val tempMap = Map("kate"->66,"mary"->77)
    scoreMap2 ++= tempMap


    val res4 = scoreMap2 -"lisi"


    val res5 = scoreMap2- ("wangwu","zhangsan")




    println("开始遍历========")

    // 遍历
    for (k <- scoreMap2.keySet) {
      println(k+" " + scoreMap2.getOrElse(k,0))
    }



    // 遍历三种常用方式
    for (k <- res4.keySet) {
      println(k+" " + res4.getOrElse(k,0))
    }


    for (elem <- res4)
      println(elem)
    // 打印出来的是元祖

    for ((k,v) <- res4)
      println(k+":" +v)


    // hashMap
    val hashMap1 = new mutable.HashMap[String,Int]()

    // 添加元素
    hashMap1("scala")
    hashMap1 +=(("java",2))
    hashMap1.put("c", 3)

    println(hashMap1)


    // 删除元素
    hashMap1 -= "scala"
    hashMap1.remove("java")
    println(hashMap1)

    // map元素格式》=5 底层的是hashmap实现的

    println()
  }

}

tuple元组

存放不同类型的值，值得个数>=2,Scala支持的元素的元组中元素个数是22，如果元素个数超过22，就需要使用其他集合。或者自己定义元组tuple，支持更长的元素个数的那种。。。

package ScalaStudy_day02

object TupleDemo {

  def main(args: Array[String]): Unit = {

    val tup1 = ("spark", "hadoop", 1)
    val tup2 = new Tuple3(1,2,"scala")

    // 访问元组 出现_了    通过_下标(下标从1开始)
    println(tup1._1)
    println(tup2._2)
    println(tup1._3)

    // 遍历  了解就行

    for (elem <- tup1.productIterator)   // 加迭代器
      println(elem)


    // 拉链操作  sequenece或者其子集或者是数组

    val language = Array("java","scala","python","c++")

    val  level = Array(1,2,3)
    // 新的数组  array(("java",1),("scala",2),("python",3))
    val res = language.zip(level)

    println(res.toBuffer)
    // unzip
    res.unzip // 得到拉链之前的数组


  }

}

List

同质，里面的元素类型一致
有序（先后）

package ScalaStudy_day02

object ListDemo {

  def main(args: Array[String]): Unit = {

    // 不可变列表
    // 构建一个列表 默认不可变
    val list = List("java","scala","python")

    val list1 = List(1,2,3)

    val list2 = List(List(1,1),List(2,3),List(4,4))

    // 空的集合
    val list4 = List()

    // ::
    // 列表要么是空的(Nil),要么就是head加上一个tail列表
    val list5 = "java"::("scala"::("python"::Nil))  // list的构建过程

    val list6 = 1::2::3::Nil  // 等价list1    这是底层实现

    // 列表的访问，可以通过下标访问，下标从0开始
    println(list5(1))

    // 列表元素的添加
    val res = list :+ "c++"

    for (elem <- list)
      println(elem) // 结合没变 因为是不可变集合  模拟添加 生成了一个新的集合

    for (elem1 <- res)
      println(elem1)


    println("=======add============")
    // 添加一个集合
    val res1 = list ++ list5

    for (elem2 <- res1) {
      println(elem2)
    }

    println("========合并或者追加(++   ++: :::)===============")
    // 两个集合的合并
    val res2 = list1 ++: list5
    for(elem<- res2)
      println(elem)

    val res3 = list ::: list5
    for (elem <- res3)
      println(elem)


    // 列表的基本操作
    // val list1 = List("scala","java","python")
    // 返回列表的第一个元素
    println("-------------------------------")
    val elem = list.head
    println(elem)

    // 返回的列表去掉第一个元素之后的列表
    val res4 = list.tail
    println(res4(1))

    // 判断列表是否空
    list1.isEmpty

    // 返回列表的长度
    list1.length

    // 返回最后一个元素
    list.last

    // 逆序
    list.reverse

    // 遍历并只取出前集合元素
    list.take(2)

    val res5 = list.take(5) // 返回的还是一个list
    println(res5)


    // 高阶方法
    // val list1 = List(1,2,3)
    val res6 = list1.map(_+1)
    val res7 = list1.map((x:Int)=>x+1)  // 函数

    println(res6)
  }
}