scala之集合总结

一.概述

该集合与java中的类似,只不过scala按照其语法进行了重新实现
分为可变集合和不可变集合
常用的集合列表

 二.List

概述
        存储同一类型的顺序存储结构
        不可变,一旦定义了就不能再改变
        可嵌套定义
        如果想使用可变的话,需要手动导入包 scala.collection.mutable.ListBuffer
使用
- 定义list
 

  //整形list
    var nums:List[Int] = List(1,2,3,4)
    //String型list
    var str:List[String] = List("java","python","scala")
    //二维list
    var dim:List[List[Int]] = List(List(1,2,3),List(4,5,6))

  - 使用Nil和::来构建list

 

  //整形list
    var nums:List[Int] = 3::2::1::Nil
    //String型list
    var str:List[String] = "scala"::"python"::"java"::Nil
    //二维list
    var dim:List[List[Int]] = (1::2::3::Nil)::(4::5::6::Nil)::Nil

常用操作
        head 返回列表第一个元素
        tail 返回一个列表，包含除了第一元素之外的其他元素
        isEmpty 在列表为空时返回 true
        ::: 运算符或 List.::: () 方法或 List.concat() 方法来连接两个或多个列表
        List.fill() 方法来创建一个指定重复数量的元素列表
        List.tabulate() 方法是通过给定的函数来创建列表。
        List.reverse 用于将列表的顺序反转
示例:

package com.antg.day03.scala

object TestFunction {
  def main(args: Array[String]): Unit = {
    //整形list
    var nums:List[Int] = 3::2::1::Nil
    //String型list
    var str:List[String] = "scala"::"python"::"java"::Nil
    //二维list
    var dim:List[List[Int]] = (1::2::3::Nil)::(4::5::6::Nil)::Nil

    //head 返回列表第一个元素
    println(dim.head)//List(1, 2, 3)
    
    //tail 返回一个列表，包含除了第一元素之外的其他元素
    println(nums.tail)//List(2, 1)
    
    //isEmpty 在列表为空时返回 true
    println(nums.isEmpty)//false
    
    //::: 运算符或 List.:::() 方法或 List.concat() 方法来连接两个或多个列表
    var a = nums:::4::Nil
    var b = nums.:::(4::Nil)
    var c = nums.concat(4::Nil)
    println(a)//List(3, 2, 1, 4)
    println(b)//List(4, 3, 2, 1)
    println(c)//List(3, 2, 1, 4)
    
    //List.fill() 方法来创建一个指定重复数量的元素列表
    var d = List.fill(3)("java")
    println(d)//List(java, java, java)
    
    //List.tabulate() 方法是通过给定的函数来创建列表。
    var e = List.tabulate(3)(x=>x+1)
    println(e)//List(1, 2, 3)
    var f = List.tabulate(3,4)((x,y)=>x+y)
    println(f)//List(List(0, 1, 2, 3), List(1, 2, 3, 4), List(2, 3, 4, 5))
    
    //List.reverse 用于将列表的顺序反转
    println(nums.reverse)//List(1, 2, 3)
  }
}

三.Set

概述
        没有重复的对象集合,底层是哈希结构
        默认是不可变的
        如果想变,引入包 scala.collection.mutable.Set
使用
不可变Set
 

  var a = Set(1,2,3,2,2,2,2)
    println(a)//1,2,3
    var b = Set(4,5,6)
    var c = a.concat(b)
    println(c)//5,1,6,2,3,4

可变Set

    var a = Set(1,2,3,2,2,2,2)
    //添加元素
    a.add(4)
    //删除元素
    a.remove(1)
    println(a)//2,3,4

• 常用操作
  • head 返回集合第一个元素
  • tail 返回一个集合，包含除了第一元素之外的其他元素
  • isEmpty 在集合为空时返回 true
  • 使用 **++ **运算符或 **Set.++() **方法来连接两个集合
  • 使用 Set.min 方法来查找集合中的最小元素，使用 Set.max 方法查找集合中的最大元素
  • 使用 Set.& 方法或 Set.intersect 方法来查看两个集合的交集元素。

示例
 

   var a = Set(1,2,3)
    //head 返回集合第一个元素
    println(a.head)//1

    //tail 返回一个集合，包含除了第一元素之外的其他元素
    println(a.tail)//HashSet(2, 3)

    //isEmpty 在集合为空时返回 true
    println(a.isEmpty)//false

    //使用 ++ 运算符或 Set.++() 方法来连接两个集合
    var b = Set(4,5,6)
    println(a++b)//HashSet(1, 2, 3, 4, 5, 6)

    //使用 Set.min 方法来查找集合中的最小元素，使用 Set.max 方法查找集合中的最大元素
    println(a.min)//1
    println(a.max)//3

    //使用 Set.& 方法或 Set.intersect 方法来查看两个集合的交集元素。
    var c = Set(2,3,4)
    println(a.&(c))//HashSet(2, 3)

四.Map

• 概述
  • 一种可迭代的键值对（key/value）结构，也称为哈希表
  • 所有的值都可以通过键来获取，键值是唯一的
  • 两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以
  • 默认使用的不可变 Map，可变的 Map 需要使用 **import scala.collection.mutable.Map **类

使用
 

  //不可变Map
    var a = Map("a"->1,"b"->2)
    val a1 = Map("a"->1,"b"->2)
    //添加元素
    a+=("c"->3)
    //a1+=("c"->3) 这个会报错
    println(a)//Map(a -> 1, b -> 2, c -> 3)
    
    //可变Map
    var b = scala.collection.mutable.Map("a"->1,"b"->2)
    b.put("c",3)
    println(b)//HashMap(a -> 1, b -> 2, c -> 3)

• 关于不可变和可变 Map 的总结
  • 不可变 Map
    • api 不太丰富
    • 如果是 var 修饰，引用可变，支持读写
    • 如果是 val 修饰，引用不可变，只能写入一次值，其后只读
  • 可变Map
    • api 丰富与 Java 中 Map 基本类似
    • 如果是 var 修饰，引用可变，支持读写
    • 如果是 val 修饰，引用不可变，支持读写
  • 总结
    • 可变与不可变，主要是通过 val 和 var 来限定达到意图
    • api 丰富程度不一样
• 常见操作
  • keys：返回 Map 所有的键(key)
  • values：返回 Map 所有的值(value)
  • isEmpty：在 Map 为空时返回 true
  • 使用**++**运算符或 **Map.++()**方法来连接两个 Map，Map 合并时会移除重复的 key。
  • 通过 foreach 循环输出 Map 中的 keys 和 values
  • 使用 **Map.contains **方法来查看 Map 中是否存在指定的 Key

示例
 

   var a = Map("a" -> 1, "b" -> 2, "c" -> 2)
    //keys：返回 Map 所有的键(key)
    println(a.keys) //Set(a, b)

    //values：返回 Map 所有的值(value)
    println(a.values) //Iterable(1, 2, 2)

    //isEmpty：在 Map 为空时返回 true
    println(a.isEmpty) //false

    //使用++运算符或 Map.++()方法来连接两个 Map，Map 合并时会移除重复的 key。
    var b = Map("c" -> 3, "d" -> 4)
    println(a ++ b) //HashMap(a -> 1, b -> 2, c -> 3, d -> 4)

    //通过 foreach 循环输出 Map 中的 keys 和 values
    a.keys.foreach(x => println(x + "---->" + a.get(x))) //a---->Some(1),b---->Some(2),c---->Some(2)
    a.foreach(x => println(x)) //(a,1),(b,2),(c,2)

    //使用 Map.contains 方法来查看 Map 中是否存在指定的 Key
    println(a.contains("a")) //true

五.元组

• 概念
  • 与列表相似，元组是不可变的
  • 与列表不同的是，元组可以包含不同类型的元素
  • 元组是通过"()"来定义的
  • 访问具体元素通过 ._index来访问,index起始值为1

使用
   

 //直接定义元组
    var a = (1,2,3,"java","scala","python")
    println(a)//(1,2,3,java,scala,python)

    //通过Tuple定义元组
    var b = new Tuple3(1,2,"java")
    println(b)//(1,2,java)

    //访问某个元素
    println(a._1)//1
    println(a._2)//2
    println(a._3)//3

    //遍历
    a.productIterator.foreach(x=>println(x))

六.Option

• 概述
  • 表示有可能包含值的容器，也可能不包含值。主要用来表示一个值是可选的
  • Option[T] 是一个类型为 T 的可选值的容器： 如果值存 在， Option[T] 就是一个 Some[T] ，如果不存在，Option[T] 就是对象 None 。
• 常用方法
  • getOrElse() 方法来获取元组中存在的元素或者使用其默认的值
  • isEmpty() 方法来检测元组中的元素是否为 None

示例
 

  //定义一个map
    var map = Map("java"->1,"scala"->2)

    //通过get方法获得的就是一个option
    println(map.get("java"))//Some(1)
    println(map.get("c"))//None

    //isEmpty() 方法来检测元组中的元素是否为 None
    println(map.get("java").isEmpty)//false

    //getOrElse() 方法来获取元组中存在的元素或者使用其默认的值
    println(map.get("scala").getOrElse())//2

七.Iterator(迭代器)

• 概述
  • 不是一个集合,它是一种访问集合的方法
  • 基本操作是 hasNext 和 next
• 常用操作
  • it.hasNext() 用于检测集合中是否还有元素
  • it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态
  • max:取得迭代器对应集合的最大值
  • min:取得迭代器对应集合的最小值
  • size/length：取得迭代器对应集合的长度

示例
 

   //遍历
    var a = Iterator("java", "scala", "c++")
    while (a.hasNext) {
      println(a.next())
    }

    //求最大值
    var b = Iterator(1, 2, 3)
    println(b.max)


    //求最小值
    var c = Iterator(1, 2, 3)
    println(c.min)

    //求长度
    var d = Iterator(1, 2, 3)
    println(d.length)