Scala Day3

最新推荐文章于 2023-03-06 22:06:24 发布

caijq_newid

最新推荐文章于 2023-03-06 22:06:24 发布

阅读量126

点赞数

分类专栏： scala

本文链接：https://blog.csdn.net/cjqnewid123/article/details/109304115

版权

scala 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Scala Day3

集合/数组（重点）

Array-数组

//伴生对象创建数组
var a1=Array(1,2,3,5,4)
//创建长度为5的数组，所有值都是0
var a2=new Array[Int](5)

//获取长度
a1.length
a2.size
//修改
a1(1) = -1
a1.update(1,-2)

//遍历数组
for(i <- a1) println(i)

Range-区间

产生的是一个只读区间和数组类似，但是内容不可以修改。

//创建区间
var r1=new Range(0,10,3) //0  3  6  9
var r2=0.to(10).by(3)
var r3=0 until 10 by 3

//取值
r1(2) // 6
//r1(2) = 12 //错误

//遍历range
for(i<- r1) println(i)
//长度大小
r1.size
r1.length

Vector-坐标

//创建向量
var v1= Vector(1,2,3)
var v2= for(i <- 0 to 10 by 3) yield i
//取值
v1(0) //1
//不支持修改
//v1(2) = 12 //错误
//遍历Vector
for(i<- v1) println(i)
//长度大小
v1.size
v1.length

Iterator -游标

不可以根据下标读取，且只能遍历一次。

//创建一个游标
var it=Iterator(1,2,3)
//只可以被遍历一次
for(i<- it) println(i)
//计算大小.将集合清空
it.size
it.length
//判断是否为空
val flag= it.isEmpty

List-不可变集合

var l1=List(1,2,3,4,5) //使用伴生对象构建集合

//迭代遍历
for(i<- 0 until l1.size){
    print(l1(i)+"\t")
}
println()

//操作位置元素 - 读取

var item0=l1(0) //获取第0个位置元素
val firstEle = l1.head //获取第0个元素
val lastEle = l1.last //获取最后一个
val tailList = l1.tail //除第一个元素以外其余元素
println(s"${item0}\t${firstEle}\t${lastEle}\t${tailList.mkString(",")}")

//判断元素是否存在
val isExists = l1.contains(5)

//高级方法
val newList1: List[Int] = l1.+:(-1) //-1,1,2,3,4,5
val newList2 = l1.::(-1) // -1,1,2,3,4,5
val newList3 = l1.:::(List(0, 0)) // 0,0,1,2,3,4,5
val newList4 = l1.++(Array(0, 0)) // 1,2,3,4,5,0,0
val newList5 = l1.++:(Array(0, 0)) //0,0,1,2,3,4,5
val newList6 = l1.:+(-1)//1,2,3,4,5,-1

//           初始值 跌倒变量 元素
val sum1 = l1./:(0)((sum, i) => sum+i)
//           初始值 元素 跌倒变量
val sum2 = l1.:\(0)((i, sum) => sum+i)

ListBuffer-可变集合

var l1=ListBuffer(1,2,3,4,5) //使用伴生对象构建集合

//迭代遍历
for(i<- 0 until l1.size){
    print(l1(i)+"\t")
}
println()

//操作位置元素 - 可读可写

var item0=l1(0) //获取第0个位置元素
val firstEle = l1.head //获取第0个元素
val lastEle = l1.last //获取最后一个
val tailList = l1.tail //除第一个元素以外其余元素
println(s"${item0}\t${firstEle}\t${lastEle}\t${tailList.mkString(",")}")


//判断元素是否存在
val isExists = l1.contains(5)

//高级方法
val newList1: ListBuffer[Int] = l1.+:(-1) //-1,1,2,3,4,5
//val newList2 = l1.::(-1) // -1,1,2,3,4,5
//val newList3 = l1.:::(List(0, 0)) // 0,0,1,2,3,4,5
val newList4 = l1.++(Array(0, 0)) // 1,2,3,4,5,0,0
val newList5 = l1.++:(Array(0, 0)) //0,0,1,2,3,4,5
val newList6 = l1.:+(-1)//1,2,3,4,5,-1

//           初始值 跌倒变量 元素
val sum1 = l1./:(0)((sum, i) => sum+i)
//           初始值 元素 跌倒变量
val sum2 = l1.:\(0)((i, sum) => sum+i)


println(sum1 +"\t"+sum2)

//修改指定位置的值
l1(0) = -1
l1.update(1, 10) // -1,10,3,4,5

//删除、插入指定位置元素
l1.remove(0) // 10,3,4,5
l1.insert(0,0,-1) //0,-1,10,3,4,5
//移除指定元素
var newRemoveList1=l1.-(-1) // 并不改变l1本身数据 l1:0,-1,10,3,4,5 newRemoveList1：0,10,3,4,5
l1.-=(5) //删除元素，修改l1本身 l1:0,-1,10,3,4

Set-不可变

//创建集合 去重
var s=Set[Int](1,2,4,5,3)

//添加一个元素  产生新的集合Set,不会修改原始集合
s.+(6) //Set(5, 1, 6, 2, 3, 4)

//删除元素 产生新的集合Set,不会修改原始集合
s.-(5) // Set(1, 2, 3, 4)

//获取set大小
s.size

//添加一个集合 产生新的集合Set,不会修改原始集合
s.++(List(6,6,7)) //Set(5, 1, 6, 2, 7, 3, 4)

//判断元素是否存在
var isExists=s(5) //true  s.contains(5)
isExists=s(7)    //false

Set-可变

import scala.collection.mutable.Set

//创建集合 去重
var s=Set[Int](1,2,4,5,3)

//添加一个元素  产生新的集合Set,不会修改原始集合
s.+(6) //Set(5, 1, 6, 2, 3, 4)

//添加一个元素  产生新的集合Set,修改原始集合
s.add(6) //Set(5, 1, 6, 2, 3, 4)

//删除元素 产生新的集合Set,不会修改原始集合
s.-(5) // Set(1, 2, 3, 4)

//删除元素 产生新的集合Set,修改原始集合
s.remove(5) //Set(1, 2, 3, 4)

//获取set大小
s.size

//添加一个集合 产生新的集合Set,不会修改原始集合
s.++(List(6,6,7)) //Set(5, 1, 6, 2, 7, 3, 4)

//判断元素是否存在
var isExists=s(5) //true s.contains(5)
isExists=s(7)    //false

HashMap-不可变

import scala.collection.immutable.HashMap

var hm= HashMap[String,String](("建设","001"),("招商","002"))

//添加一个元素，并不会修改原始的Map
hm.+(("农业","003"))
hm.+("民生"->"004")

//删除元数据，并不会修改原始的Map
hm.-("建设","招商")

//获取指定key的值
val value: Option[String] = hm.get("建设")
val sv1= value.get //该值必须存在
val sv2= value.getOrElse("啥也没有" )
val sv3=hm("建设")//直接取值

//判断key是否存在
hm.contains("建设")

//更新一个key，并不会修改原始的Map
hm.updated("建设","003")

//获取所有keys
val keys = hm.keys
val values = hm.values

//遍历一个Map
for(i<- hm.keys){
  println(i+" "+hm.get(i).getOrElse(""))
}

//合并两个map
var hm2=HashMap[String,String]("工商"->"003",("建设","005"))

//在key出现重复的时候,使用t2覆盖t1的元素
hm.merged(hm2)((t1,t2)=> t2)

HashMap-可变

import scala.collection.mutable.HashMap

var hm= HashMap[String,String](("建设","001"),("招商","002"))

//添加一个元素，并不会修改原始的Map
hm.+(("农业","003"))
hm.+("民生"->"004")

//添加一个元素，修改原始的Map
hm.put("工商","005")

//删除元数据，并不会修改原始的Map
hm.-("建设","招商")

//删除元数据，修改原始的Map
hm.remove("建设")

//获取指定key的值
val value: Option[String] = hm.get("建设")
val sv1= value.get //该值必须存在
val sv2= value.getOrElse("啥也没有" )

//判断key是否存在
hm.contains("建设")

//更新一个key，并不会修改原始的Map
hm.updated("建设","003")

//获取所有keys
val keys = hm.keys
val values = hm.values

//遍历一个Map
for(i<- hm.keys){
  println(i+" "+hm.get(i).getOrElse(""))
}

Java集合和Scala集合相互转换

import scala.collection.JavaConverters._

object TestJavaScalaCollection {
  def main(args: Array[String]): Unit = {
    val arrayList = new util.ArrayList[String]()

    arrayList.add("hello")
    arrayList.add("word")

    for(i <- 0 until  arrayList.size()){
      println(arrayList.get(i))
    }

    val scalaList = arrayList.asScala
    for(i<- scalaList){
      println(i)
    }

    val javaList = scalaList.asJava
    for(i <- 0 until  javaList.size()){
      println(javaList.get(i))
    }

  }
}

集合变换-算子

Scala集合提供了丰富的集合计算算子，用于实现集合/数组的计算，这些计算子一般针对于List、Array、Set、Map、Range、Vector、Iterator等实现集合变换，这里的变换并不会更改原始集合，仅仅通过一些算子产生新的集合。

排序

sorted

scala>  var list=List(1,5,3,4,7,6)
list: List[Int] = List(1, 5, 3, 4, 7, 6)

scala> list.sorted # 敲击键盘tab键，会有方法的提示
   def sorted[B >: Int](implicit ord: scala.math.Ordering[B]): List[Int]

scala>     val sortedList = list.sorted
sortedList: List[Int] = List(1, 3, 4, 5, 6, 7)

scala> list.sorted
res7: List[Int] = List(1, 3, 4, 5, 6, 7)

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

scala> implicit val myOrder=new Ordering[Int]{ //降序排列
     |        override def compare(x: Int, y: Int): Int = {
     |          (x-y) * -1
     |        }
     |      }
myOrder: Ordering[Int] = $anon$1@1c510181

scala> list.sorted(myOrder)
res9: List[Int] = List(7, 6, 5, 4, 3, 1)

如果遇到了复杂排序，例如集合中存储的是一个User实例或者是一个元组，系统默认不会提供相应的隐式值。

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

scala> var userArray=Array(User(1,"zhangsan",1000),User(2,"lisi",1500),User(3,"wangwu",1200))
userArray: Array[User] = Array(User(1,zhangsan,1000.0), User(2,lisi,1500.0), User(3,wangwu,1200.0))

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

不难看出，如果想对userArray进行排序我们需要提供一个Ordering[User]的隐式值，由于系统仅仅提供了AnyVal类型的隐式值，并没有提供AnyRef的隐式值（这里的String类型除外）,如果直接执行sorted，由于找不到一个Ordering[User]的隐式值，系统运行出错。

scala> userArray.sorted
<console>:14: error: No implicit Ordering defined for User.
       userArray.sorted

用户必须自定义一个Ordering[User]隐式值，上述代码方可运行成功！

scala>  implicit val userOrder=new Ordering[User]{
     |       override def compare(x: User, y: User): Int = {
     |         ( x.salary - y.salary).asInstanceOf[Int]
     |       }
     |     }
userOrder: Ordering[User] = $anon$1@64e08192

scala> userArray.sorted
res3: Array[User] = Array(User(1,zhangsan,1000.0), User(3,wangwu,1200.0), User(2,lisi,1500.0))

sortBy

实现基于某个属性的排列，例如上例中user，我们可以指定id或者是salary排序，当然要求指定属性必须是AnyVal类型。

scala> var userArray=Array(User(1,"zhangsan",1000),User(2,"lisi",1500),User(3,"wangwu",1200))
userArray: Array[User] = Array(User(1,zhangsan,1000.0), User(2,lisi,1500.0), User(3,wangwu,1200.0))

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

①按照ID排列

scala> userArray.sortBy(user=>user.id)
res6: Array[User] = Array(User(3,wangwu,1200.0), User(2,lisi,1500.0), User(1,zhangsan,1000.0))

②按照薪资排

scala> userArray.sortBy(user=>user.salary)
res7: Array[User] = Array(User(1,zhangsan,1000.0), User(3,wangwu,1200.0), User(2,lisi,1500.0))

在案例①中我们希望按照ID的升序排列

scala> implicit val idOrder=new Ordering[Int]{
     |       override def compare(x: Int, y: Int): Int = {
     |         x-y
     |       }
     |     }
idOrder: Ordering[Int] = $anon$1@72e4f58f

scala> userArray.sortBy(user=>user.id)(idOrder) # 柯里化写法
res8: Array[User] = Array(User(1,zhangsan,1000.0), User(2,lisi,1500.0), User(3,wangwu,1200.0))

sortWith

这种排序类似与sorted，会同时提供两个需要对比的对象，我们自己定义排序规则即可，无需提供隐式值。

scala> var userArray=Array(User(1,"zhangsan",1000),User(2,"lisi",1500),User(3,"wangwu",1200))
userArray: Array[User] = Array(User(1,zhangsan,1000.0), User(2,lisi,1500.0), User(3,wangwu,1200.0))

scala> userArray.sortWith
   def sortWith(lt: (User, User) => Boolean): Array[User]

scala> userArray.sortWith((u1,u2)=>u1.salary >= u2.salary)
res9: Array[User] = Array(User(2,lisi,1500.0), User(3,wangwu,1200.0), User(1,zhangsan,1000.0))

scala> userArray.sortWith((u1,u2)=>u1.salary <= u2.salary)
res10: Array[User] = Array(User(1,zhangsan,1000.0), User(3,wangwu,1200.0), User(2,lisi,1500.0))

flatten

用于展开集合中的元素，主要作用于降维。

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

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
res20: List[String] = List(a, b, c, d, e)

scala> var lines=List("hello word","ni hao")
lines: List[String] = List(hello word, ni hao)

scala> lines.flatten
res26: List[Char] = List(h, e, l, l, o,  , w, o, r, d, n, i,  , h, a, o)


scala> var lines=List("hello word","ni      hao")
lines: List[String] = List(hello word, ni      hao)

scala>  lines.flatten(line => line.split("\\s+"))
res20: List[String] = List(hello, word, ni, hao)

√Map

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

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

scala> list.map(i=> i*i)
res22: List[Int] = List(1, 4, 16, 25)

scala> var lines=List("hello word","ni      hao")
lines: List[String] = List(hello word, ni hao)

scala> lines.flatten(line=>line.split("\\s+")).map(word=>(word,1))
res24: List[(String, Int)] = List((hello,1), (word,1), (ni,1), (hao,1))

√flatMap

对集合元素先进行转换，然后执行flatten展开降维。

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

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

scala> lines.flatMap(line=> line.split("\\s+")) // lines.flatten(line=> line.split("\\s+"))
res56: List[String] = List(Hello, World, good, good, study)

√filter/filterNot

过滤掉集合中不满足条件的元素

def filter(p: Int => Boolean): Array[Int] | def filterNot(p: Int => Boolean): Array[Int]

scala> var array=Array(1,2,4,6,5,7)
array: Array[Int] = Array(1, 2, 4, 6, 5, 7)

scala> array.filter
   def filter(p: Int => Boolean): Array[Int]

scala> array.filterNot
   def filterNot(p: Int => Boolean): Array[Int]

scala> array.filter(i => i%2==0)
res38: Array[Int] = Array(2, 4, 6)

scala> array.filterNot(i => i%2==0)
res39: Array[Int] = Array(1, 5, 7)

distinct

去除重复数据

def distinct: Array[Int]

scala> val list=List(1,2,2,3)
list: List[Int] = List(1, 2, 2, 3)

scala> list.distinct
res91: List[Int] = List(1, 2, 3)

reverse

翻转输出

def distinct: Array[Int]

scala> val list=List(1,2,2,3)
list: List[Int] = List(1, 2, 2, 3)

scala> list.sorted
res0: List[Int] = List(1, 2, 2, 3)

scala> list.sorted.reverse
res1: List[Int] = List(3, 2, 2, 1)

√groupBy

通常用于统计分析,将List或者Array转换为一个Map

def groupBy[K](f: String => K): scala.collection.immutable.Map[K,List[String]]

scala> var words=Array("hello","world","good","good","study")
words: Array[String] = Array(hello, world, good, good, study)

scala> words.groupBy(w=>w)
res8: scala.collection.immutable.Map[String,Array[String]] = Map(world -> Array(world), study -> Array(study), hello -> Array(hello), good -> Array(good, good))

scala> words.groupBy(w=>w).map(t=>(t._1,t._2.length))
res10: scala.collection.immutable.Map[String,Int] = Map(world -> 1, study -> 1, hello -> 1, good -> 2)

scala> words.groupBy(w=>w).map(t=>(t._1,t._2.length)).toList
res11: List[(String, Int)] = List((world,1), (study,1), (hello,1), (good,2))

scala> words.groupBy(w=>w).map(t=>(t._1,t._2.length)).toList.sortBy(t=>t._1)
res13: List[(String, Int)] = List((good,2), (hello,1), (study,1), (world,1))

scala>  var emps=List("1,001,zhangsan,1000.0","2,002,lisi,1000.0","3,001,王五,800.0")

scala> case class Employee(id:Int,deptNo:String,name:String,salary:Double)
defined class Employee
scala> emps.map(_.split(",")).map(ts=>Employee(ts(0).toInt,ts(1),ts(2),ts(3).toDouble)).groupBy(emp=>emp.deptNo).map(t=>(t._1,t._2.map(e=>e.salary).sum))
res69: scala.collection.immutable.Map[String,Double] = Map(002 -> 1000.0, 001 -> 1800.0)

scala> emps.map(_.split(",")).map(ts=>Employee(ts(0).toInt,ts(1),ts(2),ts(3).toDouble)).groupBy(emp=>emp.deptNo).map(t=>(t._1,(for(e<- t._2) yield e.salary).sum)).toList.sortBy(t=>t._2).reverse
res1: List[(String, Double)] = List((001,1800.0), (002,1000.0))

max|min

计算最值

def max[B >: Int](implicit cmp: Ordering[B]): Int
def min[B >: Int](implicit cmp: Ordering[B]): Int

scala> list.max
res5: Int = 5

scala> list.min
res6: Int = 1

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

scala> list.sorted.head
res8: Int = 1

scala> list.sorted.last
res9: Int = 5

maxBy|minBy

计算含有最大值或者最小值的记录,按照特定条件求最大或最小

def maxBy[B](f: ((Int, String, Int)) => B)(implicit cmp: Ordering[B]): (Int, String, Int)
def minBy[B](f: ((Int, String, Int)) => B)(implicit cmp: Ordering[B]): (Int, String, Int)

scala> var list=List((1,"zhangsan",28),(2,"lisi",20),(3,"wangwu",18))
list: List[(Int, String, Int)] = List((1,zhangsan,28), (2,lisi,20), (3,wangwu,18))

scala> list.maxBy(t=>t._3)
res12: (Int, String, Int) = (1,zhangsan,28)

scala> list.maxBy(t=>t._1)
res13: (Int, String, Int) = (3,wangwu,18)

scala> var emps=List("1,001,zhangsan,1000.0","2,002,lisi,1000.0","3,001,王五,800.0")
emps: List[String] = List(1,001,zhangsan,1000.0, 2,002,lisi,1000.0, 3,001,王五,800.0)

scala> emps.map(_.split(",")).map(w=>(w(1),w(3).toDouble)).groupBy(_._1).map(t=> t._2.maxBy(i=>i._2))
res62: scala.collection.immutable.Map[String,Double] = Map(002 -> 1000.0, 001 -> 1000.0)

scala> emps.map(line=>line.split(",")).map(ts=>(ts(1),ts(3).toDouble)).groupBy(_._1).map(_._2).map(_.maxBy(_._2))
res4: scala.collection.immutable.Iterable[(String, Double)] = List((002,1000.0), (001,1000.0))

√reduce|reduceLeft|reduceRight

 def reduce[A1 >: Int](op: (A1, A1) => A1): A1

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

scala> list.reduce((v1,v2)=>v1+v2)
res7: Int = 15

scala> list.reduceLeft((v1,v2)=>v1+v2)
res8: Int = 15

scala> list.reduceRight((v1,v2)=>v1+v2)
res9: Int = 15

scala> list.reduceRight(_+_)
res17: Int = 15

如果集合为空（没有数据），系统报错

scala> var list=List[Int]()
list: List[Int] = List()

scala> list.reduce((v1,v2)=>v1+v2)
java.lang.UnsupportedOperationException: empty.reduceLeft
  at scala.collection.LinearSeqOptimized$class.reduceLeft(LinearSeqOptimized.scala:137)
  at scala.collection.immutable.List.reduceLeft(List.scala:84)
  at scala.collection.TraversableOnce$class.reduce(TraversableOnce.scala:208)
  at scala.collection.AbstractTraversable.reduce(Traversable.scala:104)
  ... 32 elided

√fold |foldLeft|foldRight

在这里插入图片描述

def fold[A1 >: Int](z: A1)(op: (A1, A1) => A1): A1

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

scala> list.fold(0)((z,v)=> z+v)
res12: Int = 15

scala> var list=List[Int]()
list: List[Int] = List()

scala> list.fold(0)((z,v)=> z+v)
res13: Int = 0

scala> list.fold(0)(_+_)
res19: Int = 15

√aggregate

在这里插入图片描述

def aggregate[B](z: => B)(seqop: (B, Int) => B,combop: (B, B) => B): B

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

scala> list.aggregate(0)((z,v)=>z+v,(b1,b2)=>b1+b2)
res29: Int = 15

scala> list.aggregate(0)(_+_,_+_)
res33: Int = 15

scala> var list=List[Int]()
list: List[Int] = List()

scala> list.aggregate(0)((z,v)=>z+v,(b1,b2)=>b1+b2)
res31: Int = 0

我们reduce和fold计算要求计算结果类型必须和集合元素类型一致，一般用于求和性质的计算。由于aggregate计算对类型无要求，因此可以使用aggregate完成更复杂的计算逻辑，例如：计算均值

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

scala> list.aggregate((0,0.0))((z,v)=>(z._1+1,z._2+v),(b1,b2)=> (b1._1+b2._1,b1._2+b2._2))
res34: (Int, Double) = (5,15.0)

按照部门计算员工平均薪资

scala> var emps=List("1,001,zhangsan,1000.0","2,002,lisi,1000.0","3,001,王五,800.0")
emps: List[String] = List(1,001,zhangsan,1000.0, 2,002,lisi,1000.0, 3,001,王五,800.0)

scala> emps.map(line=>line.split(",")).map(ts=>(ts(1),ts(3).toDouble)).groupBy(_._1).map(t=>(t._1,t._2.map(_._2))).map(t=>(t._1,t._2.aggregate((0,0.0))((z,v)=>(z._1+1,z._2+v),(b1,b2)=> (b1._1+b2._1,b1._2+b2._2)))).map(t=>(t._1,t._2._2/t._2._1))
res63: scala.collection.immutable.Map[String,Double] = Map(002 -> 1000.0, 001 -> 900.0)

group

可以对一维度数据进行升维度

def grouped(size: Int): Iterator[List[Int]]

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

scala> list.grouped(2)
res73: Iterator[List[Int]] = non-empty iterator

scala> list.grouped(2).toList
res74: List[List[Int]] = List(List(1, 5), List(3, 4), List(2))

zip

使用zip 命令可以将多个值绑定在一起,注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数

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

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


scala> list2.zip(list1)
res75: List[(String, Int)] = List((a,1), (b,5), (c,3))

scala> list1.zip(list2)
res76: List[(Int, String)] = List((1,a), (5,b), (3,c))

zipAll

如果其中一个元素的个数比较少，可以使用zipAll用默认的元素填充

scala> var list1=List(1,5)
list1: List[Int] = List(1, 5)

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

scala> list1.zipAll(list2,100,"error")
res22: List[(Int, String)] = List((1,a), (5,b), (100,c), (100,d), (100,e))

zipWithIndex

给元素添加下标操作

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

scala> list.zipWithIndex
res28: List[(String, Int)] = List((a,0), (b,1), (c,2), (d,3), (e,4))

unzip

将一个元组分解成多个一维度集合

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

scala> v.unzip
res90: (List[String], List[Int]) = (List(a, b, c),List(1, 2, 3))

diff|intersect|union

计算差集合、交集、并集

scala> var v=List(1,2,3)
v: List[Int] = List(1, 2, 3)

scala> v.diff(List(2,3,5))
res54: List[Int] = List(1)

scala> var v=List(1,2,3,5)
v: List[Int] = List(1, 2, 3, 5)

scala> v.intersect(List(2,4,6))
res55: List[Int] = List(2)

scala> var v=List(1,2,3,5)
v: List[Int] = List(1, 2, 3, 5)

scala> v.union(List(2,4,6))
res56: List[Int] = List(1, 2, 3, 5, 2, 4, 6)

Sliding

滑动产生新的数组元素

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

scala> list.sliding(3,3)
res0: Iterator[List[Int]] = non-empty iterator

scala> list.sliding(3,3).toList
res1: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6))

scala> list.sliding(3,1).toList
res2: List[List[Int]] = List(List(1, 2, 3), List(2, 3, 4), List(3, 4, 5), List(4, 5, 6))

slice

截取数组子集

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

scala> list.slice(0,3)
res3: List[Int] = List(1, 2, 3)

scala> list.slice(3,5)
res5: List[Int] = List(4, 5)

案例剖析

① 有如下数组

var arrs=Array("this is a demo","good good study","day day up")

请统计字符出现的次数，并按照次数降序排列

scala> arrs.flatMap(_.split(" ")).groupBy(w=>w).map(t=>(t._1,t._2.size)).toList.sortBy(t=>t._2).reverse
res11: List[(String, Int)] = List((day,2), (good,2), (study,1), (a,1), (up,1), (is,1), (demo,1), (this,1))

②读取一个文本文件，计算字符出现的个数

import scala.io.Source
import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
var source=Source.fromFile("/Users/admin/IdeaProjects/20200203/scala-lang/src/main/resources/t_word")

var array=ListBuffer[String]()
val reader = source.bufferedReader()
var line = reader.readLine()
while(line!=null){
  array+=line
  line = reader.readLine()
}

array.flatMap(_.split(" "))
  .map((_,1))
  .groupBy(_._1)
  .map(x=> (x._1,x._2.size))
  .toList
  .sortBy(_._2)
  .reverse
  .foreach(i=>println(i))

reader.close()

课程总结

在笔者看来，Scala这门编程语言和Java编程语言相比而言具有很多相似点，但是两种语言在实际的开发应用领域不太一样，这里并不是说谁比谁的运行效率高，而是对于开发人员而言，使用哪种语言解决问题的时候最方便。因此在小编看来，如果是纯粹的业务建模领域开发个人还是比较喜欢使用Java编程语言，因为封装做的比较清晰可读性强。但是如果大家做的是服务器端开发，尤其是数据的处理和分析领域，个人觉得像Scala语言比较好一些，因为这些语言提供了丰富的接口调用，尤其是在集合和网络编程领域上Scala有很多的应用场景，例如：Spark开发，推荐的编程语言就是Scala.
在这里插入图片描述