Scala集合算子

集合变换-算子

Scala集合提供了丰富的计算算子，用于实现集合/数组的计算，这些算子一般针对于List，Array，Set、Map、Range、Vector、Iterator等都可以适用。

排序

• sorted

def sorted[B >: User](implicit ord: scala.math.Ordering[B]): Array[User]

scala> var list=List("a","c","d","b")
list: List[String] = List(a, c, d, b)

scala> list.sorted
res0: List[String] = List(a, b, c, d)

因为系统已经提供了相应的隐式值Ordering[String],所以用户在使用的时候一般无需要提供，如果用户需要自定义排序规则，用户可以自己提供参数，不适用默认排序规则

scala> var orde=new Ordering[String]{
   
     |       override def compare(x: String, y: String): Int = {
   
     |         x.compareTo(y) * -1
     |       }
     |     }
orde: Ordering[String] = $anon$1@35efd12c

scala> list.sorted(orde)
res4: List[String] = List(d, c, b, a)

case class User(id:Int,name:String,salary:Double)

//系统报错，没有对应的隐式值
scala> var users=Array(User(1,"张三",1000.0),User(2,"李四",1500.0),User(3,"王五",800.0))
users: Array[User] = Array(User(1,张三,1000.0), User(2,李四,1500.0), User(3,王五,800.0))

scala> users.sorted
<console>:13: error: No implicit Ordering defined for User.
       users.sorted


//可以自定义隐式值
scala> implicit  var order2=new Ordering[User]{
   
     |       override def compare(x: User, y: User): Int = {
   
     |         x.salary.compareTo(y.salary) * -1
     |       }
     |     }
order2: Ordering[User] = $anon$1@794fbf0d

scala> users.sorted
res7: Array[User] = Array(User(2,李四,1500.0), User(1,张三,1000.0), User(3,王五,800.0))

• sortBy基于单一属性排列

def sortBy[B](f: User => B)(implicit ord: scala.math.Ordering[B]): Array[User]

scala> users.sortBy(u=>u.salary)
res8: Array[User] = Array(User(3,王五,800.0), User(1,张三,1000.0), User(2,李四,1500.0))

• sortWith

def sortWith(lt: ((String, Int), (String, Int)) => Boolean): List[(String, Int)]

scala> var tuples=List(("b",1),("a",2),("d",4),("c",3),("a",1))
tuples: List[(String, Int)] = List((b,1), (a,2), (d,4), (c,3), (a,1))

scala> tuples.sortWith((t1,t2)=> {
   
     |       if(t1._1.equals(t2._1)){
   
     |         (t1._2.compareTo(t2._2)* -1) > 0
     |       }else{
   
     |         t1._1.compareTo(t2._1) > 0
     |       }
     |     })
res12: List[(String, Int)] = List((d,4), (c,3), (b,1), (a,1), (a,2))

flatten(展开)

用于展开集合中的元素，主要用于降维。
二维–>一维

def flatten: Iterator[String]

scala> var list=List(List("a","b","c"),List("d","e"))
list: List[List[String]] = List(List(a, b, c), List(d, e))

scala> list.flatten
res13: List[String] = List(a, b, c, d, e)


scala> var list=List("hello world","ni hao")
list: List[String] = List(hello world, ni hao)
//如果里面不是集合，展开的是字母
scala> list.flatten
res14: List[Char] = List(h, e, l, l, o,  , w, o, r, l, d, n, i,  , h, a, o)

def flatten[B](implicit asTraversable: List[String] => scala.collection.GenTraversableOnce[B]): List[B]

//利用隐式方法，可以展开为单词
scala> var list=List("hello world","ni hao")
list: List[String] = List(hello world, ni hao)

scala> list.flatten(item=>item.split(" "))
res15: List[String] = List(hello, world, ni, hao)

Map(转换)

该算子可以操作集合中的每一个元素，并且对集合中的每一个元素做映射(转换)

def map[B](f: Int => B): scala.collection.TraversableOnce[B]

//对现有集合进行转换，产生新的集合，不会修改原数据
scala> list.map(item=> item*item)
res16: List[Int] = List(1, 4, 9, 16, 25)

scala> list
res17: List[Int] = List(1, 2, 3, 4, 5)

_:占位符  只适用于一个参数
scala> list.map(_ * 2)
res19: List[Int] = List(2, 4, 6, 8, 10)

//错误  不知道最后_是谁
scala> list.map(_ * _)
<console>:14: error: missing parameter type for expanded function ((x$1, x$2) => x$1.$times(x$2))
       list.map(_ * _)

List(“Hello World”,“good good study”)–>
List((hello,1), (world,1), (good,1), (good,1), (study,1)),并排序

scala> var lines=List("Hello World","good good study")
lines: List[String] = List(Hello World, good good study)

scala> lines.flatten(_.split(" "))
res20: List[String] = List(Hello, World, good, good, study)

scala> lines.flatten(_.split(" ")).map(_.toLowerCase)
res21: List[String] = List(hello, world, good, good, study)

scala>