Scala学习笔记：02-Scala的数组与集合

数组

Scala 语言中提供的数组是用来存储固定大小的同类型元素。

数组声明

语法:
声明一个数组可以采用如下两种方式：

var arrayName: Array[String] = new Array[String](3);
var arrayName = Array("zhangsan","lisi","wangwu");

数组操作

• 数组遍历

    var arrayName: Array[String] = new Array[String](3);
    for(i <- 0 until arrayName.length){
      arrayName(i) = i.toString;
      println(arrayName(i))
    }

• 数组的长度:array.length
• 合并两个数组

var newArray = arrayName ++ arrayName

var newArray = arrayName.concat(arrayName)

• 查找元素所在位置，不存在返回-1

newArray.indexOf("zhangsan")

• Array.range(start,end,step) 创建一个整形数组
  前闭后开

    var newArray = Array.range(1,5,2);
    for (item <- newArray){
      println(item)
    }

输出:1 3

• Array.ofDim(n:Int) 创建一个指定长度的数组

    var newArray:Array[Int] = Array.ofDim(3)
    var newArray:Array[String] = Array.ofDim(3)

• 多维数组 Array.ofDim[类型](n,n,n)

    var newArray = Array.ofDim[Int](3,3)
    for( i <- 0 until 3; j <- 0 until 3){
      newArray(i)(j) = i * j;
    }
    for (item <- newArray){
      for (it <- item){
        print(it)
      }
      println()
    }

集合(Collection)

import scala.collection.*

List 列表

Scala列表类似于数组，可以存放相同的元素，但是列表List是不可变的，值一旦定义了就不能改变。List的特征是其元素以线性方式存储，集合中可以存放重复对象。

构造列表

//使用List
var site: List[String] = List("zhangsan","lisi");

// 构造一个列表
var site2 = "zhangsan"::Nil

//空列表
var empty = Nil

列表的基本操作

• head 返回列表的第一个元素
• tail 返回一个列表，列表包含除第一个元素以外的其他元素
• isEmpty 在列表为空时返回true
• 连接列表 List.:::(List) 或者 List.concat(List)

  def main(args: Array[String]): Unit = {
    var site1: List[String] = List("zhangsan","lisi");

    var site2 = "zhangsan"::Nil

    var site3 = site1.:::(site2)
    println(site3)

    site3 = site1.concat(site2)
    println(site3)
  }

• List.fill()

//重复3次的666
val site = List.fill(3)("666")

• List.tabulate() 通过给定的函数创建列表

object TestSet {

  def test(a: Int): Int ={
    return a+a
  }

  def test_two(a:Int, b:Int): Int ={
    //二维列表需要两个输入参数，输入参数的值分别是二维数组的下标遍历
    return a+b
  }
  def main(args: Array[String]): Unit = {
    //使用普通函数
    var site4 = List.tabulate(3)(test)
    println(site4)

    //使用匿名函数
    var site5 = List.tabulate(5)(n => n*n)

    //二维列表
    var site6 = List.tabulate(3,3)(test_two)
    println(site6)
  }
}

• List前面添加元素 ::

object TestSet {

  def test(a: Int): Int ={
    return a+a
  }

  def main(args: Array[String]): Unit = {
    //使用普通函数
    var site4:List[Int] = List.tabulate[Int](3)(test)
    val site3 = 2::Nil
    println(site3)
    
    // 头部添加元素
    val sit45 =  2 :: site4
    println(sit45)
    
    // 头部添加另一个列表的所有元素
    val site6 = site3 ::: site4 
  }
}

• List头部添加另一个List的所有元素 :::
• List.apply() 通过索引序号获取列表元素
• List.max 最大值
• List.min 最小值
• List.toArray 转换为数组
• List.toSet 转换成Set

Set 集合

Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。

Scala 集合分为可变的和不可变的集合。

默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用 scala.collection.mutable.Set 包。

基本操作：

import scala.collection.mutable.Set;

object TestSet {

  def main(args: Array[String]): Unit = {
    val studentSet: Set[String] = Set("zhangsan","lisi","wangwu")

    //添加元素
    var ret: Boolean = false
    studentSet.add("666")
    //删除元素
    ret = studentSet.remove("666")

    //update,如果included参数为false，则会删除该元素，否则不做操作
    studentSet.update("lisi",true)

    //查找元素是否存在
    ret = studentSet.apply("777")

    //合并两个Set
    val studentSet2: Set[String] = Set("111","222","lisi")
    var studentSet3 = studentSet ++ studentSet2
    studentSet3 = studentSet.concat(studentSet2)

    //取交集
    studentSet3 = studentSet.&(studentSet2)
    studentSet3 = studentSet.intersect(studentSet2)

    //最大值，最小值
    val max = studentSet.max
    val min = studentSet.min

    //首个元素
    studentSet.head
    //除了第一个元素以外的所有的Set
    studentSet.tail
    //是否为空
    studentSet.isEmpty

    //addString 添加到字符串中
    var strBuilder: StringBuilder = new StringBuilder();
    studentSet.addString(strBuilder)
    println(strBuilder.toString())

  }
}

Map 映射

Map(映射)是一种可迭代的键值对（key/value）结构。

所有的值都可以通过键来获取。

Map 中的键都是唯一的。

Map 也叫哈希表（Hash tables）。

Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。

默认情况下 Scala 使用不可变 Map。如果你需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类

在 Scala 中 你可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。

Map的基本操作

import scala.collection.mutable.Map

object TestMap {


  def main(args: Array[String]): Unit = {
    var studentMap: Map[String,Int] = Map()

    //插入
    studentMap.put("0001",1)
    studentMap.put("0002",2)
    studentMap += ("0003" -> 3)

    //获取
    var value = studentMap.apply("0001")
    value = studentMap("0001")
    var value2 = studentMap.get("0001").getOrElse(4)


    //修改值
    studentMap.update("0001",3)

    //删除一个键值对
    studentMap.remove("0001")

    //判断是否存在
    val flag = studentMap.contains("0002")
    println(flag)

    //合并两个Map
    var map2: Map[String,Int] = Map()
    map2.put("004",4)
    map2.put("005",5)

    var map3 = map2.concat(studentMap)
    map3 = map2 ++ studentMap
    map3 = map2.++(studentMap)
    println(map3)

    //循环遍历Map
    studentMap.keys.foreach{
      i =>
        print("keys = " + i)
        println(" Value = " + studentMap(i))
    }


    //keys,返回一个Set
    var keys = studentMap.keys
    println(keys)

    //values，返回一个Iterable
    var values = studentMap.values
    println(values)

    //判断是否为空
    studentMap.isEmpty

  }
}

Tuple 元组

与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。

元组的值是通过将单个的值包含在圆括号中构成的。

目前 Scala 支持的元组最大长度为 22。对于更大长度你可以使用集合，或者扩展元组。

Tuple的基本操作

object TestTuple{

  def main(args: Array[String]): Unit = {
    var t = (1,2,3,4,5,6,7,8,"9",10,11,12,13,14,15,16,17,18,19,20,21,22)
    println(t)

    //构建元组
    var t2 = new Tuple4("1",2,3,5);

    //访问元组
    println(t._1)
    println(t._2)

    //迭代元组
    t2.productIterator.foreach{
      i => println(i)
    }
  }
}

Option 选项

Scala Option(选项)类型用来表示一个值是可选的（有值或无值)。

Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。

Option的基本操作

import scala.collection.mutable.Map

object TestOption {

  def main(args: Array[String]): Unit = {
    val name: Option[String] = Some("zhangsan")
    val name2: Option[String] = None

    println(name.get)
    println(name.getOrElse("zan"))

    //在Map中get返回,可以设定默认值
    val studentMap: Map[String,Int] = Map()
    studentMap.put("0001",1)
    studentMap.put("0002",2)
    studentMap.put("0004",3)
    studentMap.put("0005",5)

    val value = studentMap.get("0003")
    println(value.getOrElse(3))

  }
}

Iterator 迭代器

Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。

迭代器 it 的两个基本操作是 next 和 hasNext。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

Iterator的基本操作

object Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
     
      while (it.hasNext){
         println(it.next())
      }
   }
}

• 获取迭代器的长度 it.length 或者it.size