scala概念以及语法总结

最新推荐文章于 2021-12-29 21:15:36 发布

meiLin_Ya

最新推荐文章于 2021-12-29 21:15:36 发布

阅读量1k

点赞数

分类专栏： Scala

本文链接：https://blog.csdn.net/meiLin_Ya/article/details/82146695

版权

Scala 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

scala介绍

如何理解函数编程
scala特点

scala语法

数据类型
变量
条件表达式
for循环，while循环
方法和函数

方法：简单方法和复杂方法

函数：函数签名，复杂函数，高阶函数，方法转化为函数

scala的集合框架

元组
数组
list
map
set

结合常用的方法：

运算符重载为方法
map
filter
flatten
flatMap
foreach
storby sortwith sorted
交集差集并集去重
count find
grouped
mkString
To until
mapValues
Reduce reduceLeft reduceRight
Fold foldLeft FoldRight
aggregate

案例联系

1.wordCount

2.编写一个方法 getValues(arr:Array[Int],v:Int) 返回数组中小于v 等于 v 大于v的元素个数要求三个值一起返回

3.数组反转两两交换 Array(1,2,3,4,5,6)

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------

scala简介：

scala语言特点：面向对象编程和函数式编程

如何理解函数是编程：

定义好规范，调用的时候，传递引用，一些列的函数调用

scala特点：

1.优雅速度快

2. 语言表达能力强

3.简易

scala的语法：

数据类型：AnyVal ,AnyRef

AnyVal :

数值类型 ： Byte Int Short Long Float Double

非数值类型： Boolean Unit

注意事项： 1. 首字母全大写全是包装类型

2.Unit 表示空值相当于Java中的void 只有一个值（）小括号

变量：

String str = “hello tom”;

两个关键字 : val var

Val 修饰的是常量相当于java中的常量不可变

Var 修饰的是变量

scala> val c=()
c: Unit = ()

scala> val a=5
a: Int = 5

scala> val a="hehe"
a: String = hehe

scala> val a="true"
a: String = true

scala> val a=true
a: Boolean = true

scala> val name:String="hehe"
name: String = hehe

scala> val name:Int="hehe"
<console>:11: error: type mismatch;
 found   : String("hehe")
 required: Int
       val name:Int="hehe"
                    ^

scala> val name="hehe"
name: String = hehe

条件表达式：

If(){}

If(){} else {}

If(){} else if(){} else if(){} else{}

1.条件表达式都有返回值

scala> val result = if(age<25){println("to young")}
to young
result: Unit = ()

2.条件表达式的返回值如果有多个分支由每一个分支最后一行决定

scala> val result = if(age<25){println("too yount")}else{age}
too yount
result: AnyVal = ()

如果各个分支返回的结果类型不一致那么此时取他们的父类行

3.如果只有一个if 没有else 那么此时 else的返回类型是unit

scala> val result = if(age<25){println(age)}
18
result: Unit = ()

4.如果if else的语句只有一行可以省略 {} 但是不建议

  def main(args: Array[String]): Unit = {

    val age = 18

    val a = if (age < 18) {
      age
    } else {
      "hehe"
    }

    println(a)
  }

for循环


object TestFor {

  def main(args: Array[String]): Unit = {

    var arr = Array[Int](1, 2, 3, 4, 5, 6);

    //循环  相当于java中的增强for循环

    for (a <- arr) {
      // println(a)
    }


    //带索引的 借助两个生成器 1.to（10）
    // 1 to 10  1-10
    // 1 until 10  1-9
    for (i <- 0 to arr.length - 1) {
      //println(i + "-----" + arr(i))
    }

    //带守卫的for循环

    for (i <- arr if (i % 2 == 0)) {
      // println(i)
    }

    //嵌套的for循环
    for (i <- 1 to 3) {
      for (j <- 1 to 3) {
        if (i != j) {
          //  print(i+"  ")
          // println(i * 10 + j + " ")
        }
      }
    }

    for (i <- 1 to 3; j <- 1 to 3; if (i != j)) {
      //  println(i * 10 + j + " ")
    }

    val reslut: Array[Int] = for (a <- arr) yield a * 10
    //println(reslut.toBuffer)


    //函数式编程的方式来写  过滤对2取余等于0的数
    arr.filter(t => t % 2 == 0).foreach(println)

    arr.map(x => x * 10).foreach(println)
  }

while循环

object TestWhile {

  def main(args: Array[String]): Unit = {

    var i = 0;
    var flag = true

    while (i < 100 && flag) {
      if (i == 5) flag = false
      // println(i)

      i += 1;
    }

    var a = 1;
    while (true) {
      println(a)
    }


    do {
      println(a);
      a += 1;
    } while (a < 15);
  }

方法和函数（重点和难点）

方法：代码的抽取和复用

scala中的方法

Def 方法名称(参数列表):返回值类型={

方法体的内容

}


  def add(a:Int,b:Int):Int={
   a+b
  }
  def add2():Int={
    100
  }
  def add3:Int={
    200
  }
 def add(x:Int*):Int={
   x // seq
   var sum = 0
   for(i<-x){
     sum+=i
   }
   sum
 }
   //有比上一个方法更简单的调用
def add1(x:Int*): Int ={
  x.sum
}

我们的返回值是可以去掉的编译器会自动帮我们推荐如果方法没有指定返回值编译器可以自动推断但是要加 = 如果不加 = 就意味着返回值为 Unit

但是有两种情况必须写明返回值类型

有return 关键字的方法必须要写明返回值类型

2.递归的情况下

方法的标签

方法名+输入参数+方法返回参数类型

函数函数是一等公民

方法也是一种特殊的函数

函数的签名

函数的签名：函数的名称输入类型的参数返回值的类型


  //定义一个求和函数   简单的定义

  //返回值由编译器判断
  val func1 = (x: Int, y: Int) => {
    x + y
  }

  //匿名函数
  (x: Int, y: Int) => x + y

  def main(args: Array[String]): Unit = {
    println(func1(10, 20))

    println()
  }

复杂的函数：

Val 函数的名称:(输入参数的类型) => 返回值类型 =(输入参数的引用)=>{

函数体

}

  val fun1: (Int, Int) => Int = (x, y) => {
    x * y + 10
  }

  val fun2: (Int, Int) => Double = (x, y) => {
    if (x > y) {
      x

    } else {
      y
    }
  }

  def main(args: Array[String]): Unit = {
    println(fun1(10, 20))
    println(fun2(10, 20))
  }

高阶函数：

函数可以做为方法的参数和返回值类型

object FunDemo3 {

  val func: (Int, Int) => Double = (x, y) => {
    x * y
  }

  def hehe(x: Int, y: Int, f: (Int, Int) => Double) = {
    f(x, y)
  }

  def main(args: Array[String]): Unit = {
    println(hehe(20, 60, func))
  }
}

方法转换成函数 : 方法名称 _

方法和函数的总结：

定义方法 def
函数 =>
函数可以做为独立的表达式单独存在
方法必须要调用不能作为独立的表达式存在
函数是一等公民和类和对象在一个级别函数可以作为方法的返回值和参数
方法本质上就是函数的一种
方法可以转换为函数

Scala的集合框架

scala把集合框架分为3种

序列： Seq

集： Set

映射： Map Iterable

每一个集合都有两个包根据包分类

不可变集合 scala.collection.immutable 默认的不需要导入的

可变集合 scala.collection.mutable.*

重点：元组数组 Map List

元组非常灵活

如何取数据？._下标

对偶元组：一种特殊的元组

Val tp = (“name”，age) Map中的每一个元素都是对偶元组

swap方法可以将两个元素进行交换

拉链操作 zip zipWithIndex

zip

zipWithIndex

tuple最多方22个元素

数组

可变数组 ArrayBuffer 长度内容都可变 scala.collection.mutable

scala> val ab = ArrayBuffer(1,2)
ab: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2)

scala> val ab1 = new ArrayBuffer[Int]()
ab1: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> ab1+=2
res3: ab1.type = ArrayBuffer(2)

scala> ab1++=ab
res4: ab1.type = ArrayBuffer(2, 1, 2)

scala> ab1-=2
res5: ab1.type = ArrayBuffer(1, 2)

scala> ab1.insert
<console>:14: error: missing argument list for method insert in trait BufferLike
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing `insert _` or `insert(_,_)` instead of `insert`.
       ab1.insert
           ^

scala> ab1.in
indexOf   indexOfSlice   indexWhere   indices   init   inits   insert   insertAll   intersect

scala> ab1.in
indexOf   indexOfSlice   indexWhere   indices   init   inits   insert   insertAll   intersect

scala> ab1.in
indexOf   indexOfSlice   indexWhere   indices   init   inits   insert   insertAll   intersect

scala> ab1.insert(0,111,1111)

scala> ab1
res8: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(111, 1111, 1, 2)

scala> ab1.insert(2,22222)

scala> ab1
res10: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(111, 1111, 22222, 1, 2)

scala> ab1.remove(1)
res11: Int = 1111

scala> ab1
res12: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(111, 22222, 1, 2)

scala> ab1.clear

scala> ab1
res14: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> ab1.isEmpty
res15: Boolean = true

不可变数组 Array 长度不可变内部可变默认的情况

  def main(args: Array[String]): Unit = {
    //val arr=Array[Int](1,23,4,3,24)

    //其实类型可以省略
    val arr = Array(1, 23, 4, 3, 24)

    //获得值
    //下标重0开始
    val age = arr(1)
    arr(2) = 45
    println(arr(2))
    println(age)

    //我们可以只初始化他的长度，但是必须指定类型

    var arr3 = new Array[Int](4)

  }

数组常用方法

scala> ab2.max
res16: Int = 7

scala> ab2.min
res17: Int = 1

scala> ab2.sum
res19: Int = 28

scala> ab2.sorted
res20: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7)
scala> ab2.sorted.reverse
res22: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(7, 6, 5, 4, 3, 2, 1)

List

不可变List 长度和内容都不可变默认的

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

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

Nil:是一个List

scala> List[Int]()==Nil
res1: Boolean = true

//例子------------------------------------

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

scala> 88::l
res5: List[Int] = List(88, 1, 2, 3, 6, 54, 5)

可变的List ListBuffer 长度和内容都可变 scala.collection.mutable.ListBuffer

scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer

scala> val list = ListBuffer(1,2,3)
list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

scala> list+=12
res27: list.type = ListBuffer(1, 2, 3, 12)

scala> list
res28: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 12)

scala> ls2
res29: List[Int] = List(6, 7, 8, 9)

scala> list+=(123,321,333)
res30: list.type = ListBuffer(1, 2, 3, 12, 123, 321, 333)

scala> list
res31: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 12, 123, 321, 333)

scala> list++=List(12,3,43,444)
res32: list.type = ListBuffer(1, 2, 3, 12, 123, 321, 333, 12, 3, 43, 444)

scala> list.insert(0,8888)

scala> list
res34: scala.collection.mutable.ListBuffer[Int] = ListBuffer(8888, 1, 2, 3, 12, 123, 321, 333, 12, 3, 43, 444)

scala> list.remove(1)
res35: Int = 1

scala> list.clear

List使用

scala> l.head
res6: Int = 1

scala> l.tail
res7: List[Int] = List(2, 3, 6, 54, 5)

scala> l.tail.tail
res8: List[Int] = List(3, 6, 54, 5)

scala> l.tail.tail.tail
res9: List[Int] = List(6, 54, 5)

Map

Map中存在的元素都是对偶元组

Key是惟一的

不可变的Map 默认的


  def main(args: Array[String]): Unit = {
    val map = Map("xiaoming" -> 20, "yilian" -> 56, "xiaomei" -> 50)

    val mao2 = new HashMap[String, Int]()
    val map3 = map ++ mao2

    //------获取值
    //1.不常用  如果key不存在对应的value 那么直接报错
    val age1=map("xiaoming")
    //2.val age1: Option[Int] = map.get("reba")  返回的是  有 Some   无 ： None
    val age2=map.get("xiaoming").get
    //3.常用
    val age3=map.getOrElse("xiaoming",0)
    println(age1)
    println(age2)
    println(age3)
    //println(map3)
  }

可变的Map scala.collection.mutable.Map 映射 key -v

Set

主要用去重

可变：


scala> val ses = Set[Int](1,2,3,4,4,5,5)
ses: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

不可变：

scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set

scala> val ms = Set[Int](10)
ms: scala.collection.mutable.Set[Int] = Set(10)

scala> ms+=(11,13)
res0: ms.type = Set(13, 10, 11)

scala> ms++=Set(1,2,3,4)
res1: ms.type = Set(1, 13, 2, 3, 10, 4, 11)

scala> ms --=Set(1)
res2: ms.type = Set(13, 2, 3, 10, 4, 11)

scala> ms.head
res3: Int = 13

scala> ms.tail
res4: scala.collection.mutable.Set[Int] = Set(2, 3, 10, 4, 11)

scala> ms.remove(2)
res5: Boolean = true

scala> ms.foreach(println)
13
3
10
4
11

去重示例

scala> val list = List(11,11,12,12,123,123,333,333)
list: List[Int] = List(11, 11, 12, 12, 123, 123, 333, 333)

scala> val list1=list.toSet
list1: scala.collection.immutable.Set[Int] = Set(11, 12, 123, 333)
scala> list1.toList
res12: List[Int] = List(11, 12, 123, 333)

集合上常用的方法

运算符重载为方法：，可以变为空格，可以省略括号

scala> 3+2
res0: Int = 5

scala> 3.+(5)
res1: Int = 8

scala> 1 to 10
res2: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1.to(5)
res3: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)

Map ：

1.map就是映射对集合中的每一个元素执行某一项操作

2.返回值正常情况下原来集合是什么类型返回什么类型

3.返回集合的元素的类型取决于我们函数的返回值类型

val f=(x:Int)=>x*10
def main(args: Array[String]): Unit = {
    val lst = List(2,3,4,5)
    val lst2: List[Int] = lst.map((t:Int)=>t*10)
    val lst3 = lst.map(f)
  //可以省略函数里的参数类型  谁调用的这个map算子  那么他里面的数据类型是啥 就是什么类型
    val lst4 = lst.map(x=>x*10)
    val fs: List[Boolean] = lst.map(x=>x%2==0)
    println(lst4)

  /**
    * 总结：
    * 1.map就是映射 对集合中的每一个元素执行某一项操作
    * 2.返回值  正常情况下 原来集合是什么类型 返回什么类型
    * 3.返回集合的元素的类型  取决于我们函数的返回值类型
    */

}

filter：过滤，过滤出来自己想要的数据

def main(args: Array[String]): Unit = {
   val list = List(Array(1,2,3),Array(4,5,6),Array(7,8,9))
  val flats: List[Int] = list.flatten
  val lst = flats
   println(lst.toBuffer)
}

flatten 压平，将一个数组种的所有数组压成一集

scala> val ar=List(List(1,2,3),List("hehe","haha"))
ar: List[List[Any]] = List(List(1, 2, 3), List(hehe, haha))

scala> ar.flatten
res4: List[Any] = List(1, 2, 3, hehe, haha)

FlatMap:压平加切割

scala> val arr = Array("hello spark","hello hadoop")
arr: Array[String] = Array(hello spark, hello hadoop)

scala> val splits = arr.map(str=>str.split(" "))
splits: Array[Array[String]] = Array(Array(hello, spark), Array(hello, hadoop))

scala> splits.flatten
res0: Array[String] = Array(hello, spark, hello, hadoop)

scala> arr.flatMap(x=>x.split(" "))
res1: Array[String] = Array(hello, spark, hello, hadoop)

Foreach 打印一个list，array，map，底层调用的是applay方法

就是对每一个元素执行操作返回值是Unit

scala> ar.foreach(println)
List(1, 2, 3)
List(hehe, haha)

Sortby sortwith sorted

Sorted: 默认是升序

Sortby : 参数是一个函数指定排序的规则默认是升序

Sortwith: 接收两个参数两个参数进行比较

scala> val lst = List(12,1,23,34,2)
lst: List[Int] = List(12, 1, 23, 34, 2)

scala> lst.sorted
res0: List[Int] = List(1, 2, 12, 23, 34)

scala> lst.sortWith((a,b)=>a>b)
res1: List[Int] = List(34, 23, 12, 2, 1)

scala> lst.sortWith((a,b)=>a<b)
res2: List[Int] = List(1, 2, 12, 23, 34)

scala> lst.sortWith((_,_)=>_>_)
<console>:13: error: missing parameter type for expanded function ((x$3, x$4) => x$3.$greater(x$4))
       lst.sortWith((_,_)=>_>_)
                           ^
<console>:13: error: missing parameter type for expanded function ((x$3: <error>, x$4) => x$3.$greater(x$4))
       lst.sortWith((_,_)=>_>_)
                             ^

scala> lst.sortWith(_>_)
res4: List[Int] = List(34, 23, 12, 2, 1)

交集差集并集去重

  并集： union

  交集： intersect

  差集： diff

  去重： distinct

scala> val arr = Array(1,2,3)
arr: Array[Int] = Array(1, 2, 3)

scala> val arr2 = Array(1,2,5)
arr2: Array[Int] = Array(1, 2, 5)

scala> arr union arr2
res5: Array[Int] = Array(1, 2, 3, 1, 2, 5)

scala> res5.distinct
res6: Array[Int] = Array(1, 2, 3, 5)

scala> arr diff arr2
res7: Array[Int] = Array(3)

scala> arr intersect arr2
res8: Array[Int] = Array(1, 2)

Count 和 find

find 返回满足条件的第一个元素 Some 没有则返回none

Count返回满足条件的所有元素的个数和

object CountAndFindDemo {
  def main(args: Array[String]): Unit = {
     val lst = List(2,3,4,5)
     val counts = lst.count(_>3)
     println("xxx"+counts)
    //find 返回满足条件的第一个元素  Some
    //filter 返回满足条件的所有元素
     val lst1 = lst.find(_>3)
    println(lst1.get)
  }
}

Grouped(n:Int) 按照指定元素的个数来分组

val arr = Array(1,2,3,4,5,5,6,6,93,3)
 arr.grouped(2)
res9: Iterator[Array[Int]] = non-empty iterator

scala> res14.foreach(arr=>println(arr.toList))
List(1, 2)
List(3, 4)
List(5, 5)
List(6, 6)

mkString：

scala> arr
res16: Array[Int] = Array(1, 2, 3, 4, 5, 5, 6, 6, 93, 3)

scala> arr.mkString
res17: String = 12345566933

scala> arr.mkString("@")
res18: String = 1@2@3@4@5@5@6@6@93@3

To until 其实他们都还可以指定步长

scala> 1 to 10
res19: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1.to(10,2)
res20: scala.collection.immutable.Range.Inclusive = Range(1, 3, 5, 7, 9)

scala> 10.to(1,-3)
res21: scala.collection.immutable.Range.Inclusive = Range(10, 7, 4, 1)

mapValues 和 map类似只不过 mapValues 处理的Map集合中的value值 key保持不变

def main(args: Array[String]): Unit = {
    val mp = Map[String,Int]("a"->1001,"b"->1002,"c"->1003)
    mp.map(t=>(t._1,t._2*10)).foreach(println)
    mp.mapValues(_*10).foreach(println)
}

Reduce reduceLeft reduceRight

Reduce: 元素的归并元素的聚合具体如何聚合取决于我们的函数

def main(args: Array[String]): Unit = {
   val a1 = Array[Int](1,3,4,5)
   //求和
    val r1 = a1.reduce((a,b)=>a+b)
    val r2 = a1.reduce(_*_)
    println(r1+","+r2)
   val a2 = List("1","2","3")
//  a2.reduceLeft()
   println(a2.reduce(_+_))
  //reduceLeft  reduceRight
  //reduceLeft 向左归并  reduceRight 向右归并
  println("=============")
  println(a1.reduce(_-_))
  println(a1.reduceLeft(_-_))
  println(a1.reduceRight(_-_))

}

Fold foldLeft FoldRight

Fold ：带初始值的归并和 reduce相比一样就比他多了一个初始值

foldLeft 从左向右归并

foleRgith 从右向左归并

def main(args: Array[String]): Unit = {
    val a1 = Array(1,2,3,4,5)
    println(a1.fold(10)(_+_))
    println(a1.foldLeft(10)(_+_))
   println(a1.foldRight(10)(_+_))
   println("================")
  println(a1.fold(10)(_-_))
  println(a1.foldLeft(10)(_-_))
  println(a1.foldRight(10)(_-_))
}

Aggregate

Aggregate :聚合

单机版的aggregate 调用的是 fold

第一个函数：局部聚合

第二个函数：全局聚合

def main(args: Array[String]): Unit = {
    val arr = Array(1,2,3,4,4,5)
  //在scala中 因为没有局部和全局的概念 只会执行第一个函数
    val a1 = arr.aggregate(0)(_+_,_*_)
    println(a1)
}

案列：

1.wordcount案例

 def main(args: Array[String]): Unit = {

    val list = List("hello world hello tom", "hello storm hello spark hello spark hello spark hello spark", "hello scala world world world")

    val strings = list.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.size).toList.sortBy(_._2).reverse.foreach(println)

    val strings = list.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.foldLeft(0)(_ + _._2)).toList.sortBy(_._2)
    val strings = list.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues()
    val result = list.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.map(_._2).sum).toList.sortBy(_._2).reverse.foreach(print)
    println(result)

  }

2.编写一个方法 getValues(arr:Array[Int],v:Int) 返回数组中小于v 等于 v 大于v的元素个数要求三个值一起返回

def getCounts(arr:Array[Int],v:Int):(Int,Int,Int)={
      val v1 = arr.count(_ < v)
      val v2 = arr.count(_ == v)
      val v3 = arr.count(_ > v)
      (v1,v2,v3)
    }

3.数组反转两两交换 Array(1,2,3,4,5,6)

def swap(arr:Array[Int]):Array[Int]={
      for(i <- 0 to (arr.length-1-1,2 )){
        //定义一个中间变量
        val tmp = arr(i)
        arr(i) = arr(i+1)
        arr(i+1) = tmp
      }
      arr
}

meiLin_Ya

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
scala概念以及语法总结

scala介绍如何理解函数编程 scala特点scala语法数据类型变量条件表达式 for循环，while循环方法和函数方法：简单方法和复杂方法函数：函数签名，复杂函数，高阶函数，方法转化为函数 scala的集合框架元组数...
复制链接

扫一扫