Scala语言知识总结

最新推荐文章于 2021-05-27 16:38:19 发布

白菜banger

最新推荐文章于 2021-05-27 16:38:19 发布

阅读量158

点赞数

文章标签： Scala

本文链接：https://blog.csdn.net/weixin_40105543/article/details/96275870

版权

Scala语言

Scala是基于JVM的语言

一.六大特性

1.与Java无缝整合

2.类型推断

3.支持分布式和并发Actor

4.Trait特质特征

5.模式匹配match

6.高阶函数

二.类和对象

1.当new类时,类中除了方法不执行,其他都执行

2.object相当于Java中单例,定义的都是静态的

3.class可以传参数,传参就有默认的构造

4.重写构造时,第一行要先调用默认的构造

5.for循环:

1 to 10

1 unitl 10

for(i<-1 to 10)

6.while… do…while…循环: i+=1 i-=1 (没有i++,i–)

7.if…else…条件判断:与Java一样

8.Object不可以传参,如果有参数:apply()方法

9.伴生对象:如果在同一个文件中,object对象和class类的名称相同,则这个对象就是这个类的伴生对象,这个类就是这个对象的伴生类,可以互相访问私有变量.

三.方法和函数

1.方法定义:

1).方法的定义 def

2).方法中传参要指定类型

3).方法自己可以推断返回类型,默认将方法体中最后一行计算的结果当作返回值返回

4).如果要写return返回值,要显示的声明方法体的返回值类型

5).如果方法体可以一样搞定,可以将方法体"{…}"大括号去掉

6).如果方法名称和方法体之间没有"=",无论方法体返回什么值,都会被丢弃返回Unit

2.递归方法:

要显示写出返回值类型

3.参数有默认值的方法:

def fun(x:Int=100)

4.可变长参数的方法:

def fun(x:String*)

5.匿名函数:

()=>{…}

可以赋值给一个变量,下次调用变量就是使用的这个匿名函数

6.偏引用函数:

某些情况下,方法中参数非常多,调用这个方法非常频繁,每次调用只有固定的某个参数变化,其他都不变,以定义偏应用函数

将默认的参数写死,将可变的参数用"_"来表示.

7.嵌套方法:方法套方法

8.高阶函数:

1).函数的参数是函数

2).函数的返回是函数

3).函数的参数和返回都是函数

9.柯里化函数:

高阶函数的简化

四.String

就是Java当中的String

五.集合

1.Array:

可以new也可以不new,new的话可以指定参数有几个长度,不new就可以直接写类型

2.ArrayBuffer:可变Array

3.List :有序

*val list = ListString*

map:一对一

flatMap:一对多

4.ListBuffer:可变List

5.Set:无序

引入包:

可变:import scala.collection.mutable

不可变:import scala.collection.immutable

6.Map:map中的元素就是一个个的二元组

1).引入包:

可变:import scala.collection.mutable

不可变:import scala.collection.immutable

2).map.keys:拿到所有的key

3).map.values:拿到所有的value

4).val option = map.get(key):拿到key

5).val value = map.get(key).getOrElse(…):当拿不到值的时候输出(…) 内的值

6).添加map ++: ++两个map的合并带":“前面往后面合并,不带”:"后面往前面合并

7.Tuple:元组

1).最多支持22个元素

2).遍历元组:val iter = tuple.prduceIterator(元组没有for… foreach…循环)

3).二元组中有个swap翻转

4).元组取值 tuple:_xxx

六.Trait

1.相当于Java中的接口和抽象类结合

2.可以在Trait中定义方法的实现与不实现,变量和常量都可以

3.Trait不可以传参

4.类继承Trait 第一个关键字使用extends,之后都使用with

七.模式匹配

1.match …case…

2.模式匹配中既可以匹配值,也可以匹配类型

1).匹配值: case 123=>{…}

2).匹配类型: case i:Int =>{…}

3.模式匹配中,从上往下匹配,匹配上了就自动终止

4.模式匹配过程中会有值转换

5.case _=>{…} 什么都匹配不上最后匹配,要写到最后

6.模式匹配 math …case… 相当于一大行

八.样例类

1.case class

2.自动实现了 toString equals hashCode 等方法

3.样例类可以new, 也可以不new

4.样例类中参数,默认有getter,setter方法.对外可见

九.偏函数

1.偏函数,只能匹配一个值,匹配上了返回某个值

PartialFunction[A,B] A是匹配的类型,B是匹配上返回的类型

2.偏函数相当于Java中的 switch…case…只能匹配相同类型

十.implicit隐式转换隐式类
1.隐式转换

1)隐式的变量,相同的类型在同一个作用域内不能出现两次,因为不知道找谁.
2)implicit必须放在隐式参数的开头
3)如果还有其他参数(多个),想要使用隐式转换需要使用柯里化函数的方式:()(隐式参数)放在后面

/**
  * 隐式转换
  *
  */
object Lesson_ImplicitTrans {
  def sayName(age:Int)(implicit name:String) = {
    println(s"$name is student.......,age is $age")
  }

  def main(args: Array[String]): Unit = {
    implicit val name:String ="zhangsan"
    sayName(12)
  }
}

2.隐式转换函数 implicit

1)隐式转换函数是使用关键字implicit修饰的方法,当Scala运行时,假设如果A变量调用了method()方法,发现A类型的变量没有method()方法,而B类型有此method()方法,会在作用域中寻找有没有隐式转换函数向A类型转换成B类型,那么A类型就可以调用method()这个方法.

2)注意:隐式转换只与函数的参数类型和返回值有关系,与函数名无关,所有作用域内不能有相同的参数类型和返回类型的不同名称隐式转换函数(只能有一种传入参数,传出参数)

/**
*  隐式转换函数
**/
class Animal(name:String){
  def canFly() = {
      println(s"$name  can fly.....")
  }
}

class Rabbit(xname:String){
 val name = xname
}
object Lesson_ImplicitTrans2 {

  implicit def RabbitToAnimal(r:Rabbit):Animal = {
      new Animal(r.name)
  }

  def main(args: Array[String]): Unit = {
    val rabbit = new Rabbit("rabbit")
    rabbit.canFly()
    }
}

3.隐式类:

使用implicit关键字修饰的类就是隐式类,若一个变量A没有某些方法或者某些变量时,而这个变量A可以调用某些方法或者某些变量时候,可以定义一个隐式类,隐式类中定义这些方法或者变量,隐式类传入A即可
注意:
1)隐式类必须定义在类,包对象,伴生对象中
2)隐式类的结构必须只有一个参数,同一个类,包对象,伴生对象中不能出现同类型构造的隐式参数

/**
*隐式类:
*/
class Rabbit1(xname:String){
  val name = xname
}

object Lesson_ImplicitTrans3 {

  implicit class Animal1(r:Rabbit1){
    def showName() = {
      println(s"${r.name} is Rabbit...")
    }
  }

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

   val rabbit = new Rabbit1("RABBIT")
    rabbit.showName()
  }
}

十一.Actor
想要使用Actor:必须先要导入jar包,这里是2.10版本:scala-actors-2.10.4.jar

1.Actor通信模型(相当于Java中的线程).有别于Java的线程阻塞lock锁,Actor是非阻塞:采用消息队列

package com.scala

import scala.actors.Actor


/**
  * Actor通信模型(相当于Java中的线程)
  * 有别于Java的线程阻塞lock锁,Actor是非阻塞:采用消息队列
  *
  *
  */
class MyActor extends Actor {
  override def act() ={
    receive{
      case s:String => {println(s"type is String value = $s")}
      case _=> {println("no match")}
    }
  }
}
object Lesson_Actor1 {
  def main(args: Array[String]): Unit = {

    var actor = new MyActor()

    actor.start()//开始发送消息

//  actor ! "helloworld"
//  actor ! 100
  }

}

2.Actor 与 Actor之间的通信模型

package com.scala

import scala.actors.Actor


/**
  * Actor 于 Actor 通信模型
  *
  *
  */

//封装的样例类
case class Msg(actor : Actor,message : String){

}

class MyActor1 extends Actor {
  override def act() ={
    while (true){
      receive{
        case msg:Msg => {
          if("hello~".equals(msg.message)){
            println(msg.message)
            msg.actor ! "hi~"
          }else if ("Could we have a date?".equals(msg.message)){
            println(msg.message)
            msg.actor ! "no!"
          }

        }
        case _=> {println("no match")}
      }
    }

  }
}

//actor1 发消息给 actor2
class MyActor2(actor:Actor) extends Actor {

  actor ! Msg(this,"hello~")//封装成一个类型(样例类)

  override def act() ={
    while (true){
      receive{
        case s:String => {
          if("hi~".equals(s)){
            println(s)

            actor ! Msg(this,"Could we have a date?")
          }else if ("no!".equals(s)){
            println(s)
            println(".......")
          }
        }
        case _=> {println("no match")}
      }
    }

  }
}

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

    var actor1 = new MyActor1()
    var actor2 = new MyActor2(actor1)

    actor1.start()
    actor2.start()


  }

}

白菜banger

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Scala语言知识总结

Scala语言Scala是基于JVM的语言一.六大特性 1.与Java无缝整合 2.类型推断 3.支持分布式和并发Actor 4.Trait特质特征 5.模式匹配match 6.高阶函数二.类和对象 1.当new类时,类中除了方法不执行,其他都执行 2.object相当于Java中单例,定义的都是静态的 3.class可以传参数,传参就有默认的构造 4...
复制链接

扫一扫