Scala数据结构(二)

一、集合的基础操作

1，head头信息

//获取集合的第一个元素

val list = List(,,)

list.head    //

2，tail尾信息

//获取集合除去头元素之外的所有元素

val list = List(,,)

list.tail //List(3,5)

3，last最后元素

//获取集合的最后一个元素

val list = List(,,)

list.last    //

4，init初始化

//获取集合除去最后一个元素的前面所有元素

val list = List(,,)

println(list.init)    //List(1,3)

5，reverse反转

//集合反转

val list = List(,,)

val resList: List[Int] = list.reverse    //List(5, 3, 1)

6，sum、max、min

val list = List(,,)

println(list.sum)    //9 求和

println(list.max)    //5 最大值        

println(list.min)    //1 最小值

7，take(n)获取前n个元素

val list = List(,,)

val takeList = list.take()    //List(1)

二、集合的高级操作

1，sortBy和sortWith

//sortBy只能按照升序排列，sortWith可自定义升降序

val list = List(,,,,,)

val sortByList: List[Int] = list.sortBy(x=>x)   //List(1, 3, 4, 7, 9, 10)

val sortWithList: List[Int] = list.sortWith((left,right)=>left>right)    //List(10, 9, 7, 4, 3, 1)，如果要升序可以left<right

2，groupBy分组

//定义按照元素分组会生成对应的map

val list = List(,,,,,)

val groupByMap: Map[Int, List[Int]] = list.groupBy(x=>x)    //Map(4 -> List(4), 1 -> List(1, 1), 9 -> List(9), 3 -> List(3, 3))

3，map映射

　　在Scala中可以通过map映射操作来解决：将集合中的每一个元素通过指定功能（函数）映射（转换）成新的结果集合。这里其实就是所谓的将函数作为参数传递给另外一个函数,这是函数式编程的特点

//将list集合中的每个元素*2

val list = List(,,)

val newList: List[Int] = list.map(_*) //List(2,6,10)

4，flatMap扁平化

　　将集合中的每个元素的子元素映射到某个函数并返回新的集合。

val list = List(List(,,),,List(,))

val newList = list.flatMap {

  case item =>

    //判断类型如果是List[Any]类型就转换

    if (item.isInstanceOf[List[Any]]) {

      item.asInstanceOf[List[Any]]

    } else {

      //如果是普通类型就直接List(item)包装

      List(item)

    }

}

println(newList)    //List(1, 2, 3, 1, 4, 98)

5，filter过滤

//filter过滤获取为true的元素组成集合

val list = List(, , , , , )

val filterList: List[Int] = list.filter(_ > )    //List(25, 98)

6，reduce化简

val list = List(, , , )

//1+2+3+4       10

val reduceLeft: Int = list.reduce(_ + _)

//1-(2-(3-4))   -2

val reduceRight: Int = list.reduceRight(_ - _)

7，folder折叠

val list = List(, , , ) //集合List

//(100,1, 2, 3, 4) =>化简  (((100-1)-2) -3)) – 4 = 90

println(list.foldLeft()(_-_)) // [函数柯里化(将多个参数，分别传递)]

//(1,2,3,4,100) => 化简 1-(2-(3-(4-100))) = 98

println(list.foldRight()(_-_))

8，match匹配

　　模式匹配语法中，采用match关键字声明，每个分支采用case关键字进行声明，当需要匹配时，会从第一个case分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。如果所有case都不匹配，那么会执行case _ 分支，类似于Java中default语句

val oper = '-'

val n1 =

val n2 =

var res =

oper match {

  case '+' => res = n1 + n2

  case '-' => res = n1 - n2

  case '*' => res = n1 * n2

  case  => println("")

  case '/' => res = n1 / n2

  case _ => println("oper error")

}

println("res=" + res) //

巴特西