Scala深度学习2

最新推荐文章于 2024-05-17 09:54:13 发布

LAllenKing

最新推荐文章于 2024-05-17 09:54:13 发布

阅读量292

点赞数

分类专栏： Scala 大数据

本文链接：https://blog.csdn.net/qq_42741004/article/details/100996575

版权

大数据同时被 2 个专栏收录

28 篇文章 1 订阅

订阅专栏

Scala

5 篇文章 0 订阅

订阅专栏

day02

scala中的抽象类

abstract class Father(newName:String) {

  protected var name:String=newName

  //抽象方法
  def eat(food:String):Unit

  //普通方法
  def run():Unit={
println(this.name+"is running...")
  }
}

类的继承

class Father(newName:String) {

  protected var name:String=newName

  //普通方法
  def eat(food:String):Unit={
println(this.name+"is running...")
  }
}

class Son(newName:String) extends Father(newName){
  override def eat(food:String):Unit={
println("like"+food)
  }
}

object Son{
  def main(args: Array[String]): Unit = {
val son=new Son("son1")

println(son.name)
son.eat("noodle")
  }
}
//注：在Scala的构造器中，你不能调用super（params），
// 不像java，可以用这种方式调用超类构造器

类中的get/set和辅助构造器和先决条件

class User(newId:Int,newName:String) {

  //先决条件
  require(newId > 0)
  require(!newName.isEmpty)

  private var id:Int = _
  private var name:String=_
  private var age:Int=_

  //辅助构造器
  def this(id:Int,name:String,age:Int){
this(id,name)//必须先把主构造器参数调用一遍
this.age=age
  }

//class User {
//  private var id:Int = _
//  private var name:String=_
//  private var age:Int=_
//
//  //辅助构造器
//  def this(id:Int){
//    this()
//    this.id=id
//  }
//
//  def this(id:Int,name:String){
//    this()
//    this.id=id
//    this.name=name
//  }
//
//  def this(id:Int,name:String,age:Int){
//    this()
//    this.id=id
//    this.name=name
//    this.age=age
//  }

  val getId = ()=>this.id
  val setId = (id:Int)=>this.id=id

  val getName = ()=>this.name
  val setName = (name:String)=>this.name=name

  val getAge = ()=>this.age
  val setAge = (age:Int)=>this.age=age

  override def toString: String = {
"User(id=" + this.id + ",name=" + this.name +
",age=" + this.age + ")"
  }
}

object UserTest {
  def main(args: Array[String]): Unit = {
val user = new User(10,"pp")
user.setId(1001)
user.setName("Mike")
user.setAge(18)
println(user)
  }
}

trait定义（类似java中的接口）

trait Human {//接口

  def eat(food:String):Unit
  def run():Unit
  def doSomeThing(thing:String):String
}

trait Employee {
  def work():Unit
}

实现类

class People extends Human with Employee {

  override def eat(food: String): Unit = {
println("eating: "+food)
  }

  override def run(): Unit = {
println("running...")
  }

  override def doSomeThing(thing: String): String = {
"do "+thing
  }

  override def work(): Unit = {
println("i'm working...")
  }
}

伴生对象（在java中会用到既有实例方法又有静态方法的类，scala中可以通过类和与类同名的伴生对象来达到同样的目的）

class Account {

  private val accountNumber = Account.generateNewNumber
  private val balance = 0.0

  def show():Unit={
println("accountNumber: "+accountNumber)
println("balance: "+balance)
  }
}

object Account{
  private var lastNumber = 0

  private def generateNewNumber():Int={
lastNumber += 1
lastNumber
  }
}
//注:类的伴生对象的功能特性并不在类的作用域内，
// 必须通过对象名。属性或对象名.方法来调用

应用程序对象（每个scala程序出了从一个对象的main方法启动外还可以通过继承App程序来启动程序）

//正常启动
object HelloWorld { // 程序入口
  def main(args: Array[String]):Unit = {
    println("Hello World!!") // 输出 Hello World!!
  }
}
//继承App启动
object HelloWorld extends App{
  println("Hello World!!") // 输出 Hello World!!
}
//每个Scala程序都必须从一个对象的main方法启动，
// 除了使用main方法，还可以通过继承App程序来启动程序

scala导入包求平方根

def sqrtplus1(x:Int)={
  import scala.math.sqrt
  sqrt(x)+1.0
}

变长数组（数组的长度可以改变）

object ArrayBufferTest {
def main(args: Array[String]): Unit = {
  import scala.collection.mutable.ArrayBuffer
  var arr = new ArrayBuffer[Int]()
  //添加元素
  arr += 1
  arr += 2
  arr += 3

  println(arr.mkString(","))
    }
  }

常用算术操作

def main(args: Array[String]): Unit = {
import scala.collection.mutable.ArrayBuffer
val arr = ArrayBuffer[Int](1,2,3,4,5,6,7,8)
//求和
println("sum: "+arr.sum)
//求极值
println("max: "+arr.max)
println("min: "+arr.min)
//简单排序
var sortedArr = arr.sorted
sortedArr.foreach(println)
}

定义样例类

//定义样例类
//一个最简单的案例类定义由关键字case class,类名，参数列表（可为空）组成
object CaseClassTest{
  case class Person(id:Int,name:String)

  def main(args: Array[String]): Unit = {
//case class会自动生成apply方法，创建对象时无需用new
val person = Person(1001,"Mike")
println("person: "+person)
  }

定义泛型类（Stack类的实现可以用任意类型A作为参数）

//泛型类
class Stack[A]{
  private var elements:List[A]= Nil
  def push(x:A){elements=x::elements}
  def peek:A=elements.head
  def pop()：A={
val currentTop = peek
elements=elements.tail
currentTop
  }
}

使用泛型类（使用具体的类型替换A）

//使用
val stack = new Stack[Int]
stack.push(1)
stack.push(2)
println(stack.pop)//prints 2
println(stack.pop)//prints 1

map函数（map操作时针对集合的典型变换操作，它将某个函数应用到集合中的每个元素，并产生一个结果集合）

val salaries = seq(20000,70000,40000)
val doubleSalary=(x:Int)=>x*2
val newSalaries = salaries.map(doubleSalary)//List(40000,140000,80000)

//简化代码
val salaries = Seq(20000,70000,40000)
val newSalaries= salaries.map(x=>x*2)
//上述示例中x没有被显式声明为int类型，这是因为编译器能够根据map函数期望的类型推断出x的类型
//对于上述代码，一种更惯用的写法为
val salaries = seq(20000,70000,40000)
val newSalaries= salaries.map(_*2)

flatMap函数（flatMap是map的一种扩展。在flatMap中，我们会传入一个函数，该函数对每个输入都会返回一个集合（而不是一个元素),然后，flatMap把生成的多个集合“拍扁”成为一个集合）

val words = Seq("H e l l o","W r o l d")
val result = words.flatMap(_.split(" "))
println("result: "+ result)

reduce函数（reduce函数可以对集合当中的元素进行归约操作，其中下划线是占位符，两个下划线表示归约的规则是使用前后两个元素，中间的加号，用来表示对元素的操作，这里我们使用的是加法如果我们不指定reduce是left还是right默认情况下会使用reduceLeft执行操作）

val list = List(1,2,3,4,5,6)
//val result = list.reduceLeft(_+_)
//val result = list.reduceRight(_+_)
val result = list.reduce(_+_)
println("result: "+result)

foreach函数（foreach函数与map函数相似，都是用于遍历集合对象，并对每一项执行指定的方法，但两者的差异在于：foreach无返回值（准确来说是void），map返回集合对象）

val list = List(1,2,3,4,5,6)
list.foreach(println)

groupBy函数（groupBy函数将列表进行分组，分组的依据是应用groupBy函数中函数的返回值）

val list = List("a","b","c","d")
val result = list.groupBy(x=>{
  x match{
case "a"=>1
case "b"=>1
case _=>2
}
})
println(result)
//====================================
val seq = Seq((100,"Mike"),(85,"Bob"),(90,"Mike"))
val result = seq.groupBy(_._2)
println(result)

filter函数（filter函数用于保留列表中符合条件的列表元素）

val list=List(100,80,60,95,88)
val newList = list.filter(_>60)
println("newList: "+newList)

count函数（count函数计算列表中所有满足条件的元素的个数）

val list = List(100,80,60,95,88)
val newList = list.count(_>60)
println("newList: "+newList)

sortBy函数（sortBy函数用于通过它的类型对一个属性或多个属性进行排序）

val list = List(100,80,60,95,88)
val newList = list.sortBy(x=>x)
//val newList = list.sortBy(x=>x).reverse
println("newList: "+newList)

diff函数（diff函数用于保存列表中那些不在另外一个列表中的元素，即从集合中减去与另外一个集合的交集）

val list1 = List(1,2,3,4,5,6)
val list2 = List(3,4,6)
val list3 = list1.diff(list2)
println(list3)

union函数（union函数用于保存两个集合的元素）

val list1 = List(1,3,5,6)
val list2 = List(2,4,6)
val list3 = list1.union(list2)
println(list3)

intersect函数（intersect函数用于保存与另外一个集合的交集）

val list1 = List(1,3,5,6)
val list2 = List(2,4,6)
val list3 = list1.intersect(list2)
println(list3)

take函数（take函数用于提取列表的前n个元素）

val list = List(1,3,5,7,9,7,9)
val takeList = list.take(3)
println("take list: "+takeList)

drop函数（drop函数用于丢弃前n个元素，返回剩下的元素）

val list = List(1,3,5,7,9,7,9)
val dropList = list.drop(3)
println("drop list: "+dropList)

partition函数（partition函数用于将列表分为两部分，第一部分为满足条件的元素，第二部分为不满足条件的元素）

val list = List(1,2,3,4,5,6,7,8,9)
val lists = list.partition(_%2==0)
println(lists)

隐式转换（将高精度类型转换为低精度类型）

val num:Int = 12.5//提示错误，高精度无法自动转换为低精度类型
println("num: "+num)

//加入隐式转换
implicit def f1(x:Double):Int ={
  x.toInt
}
  def main (args: Array[String] ): Unit = {
val num:Int = 12.5//代码正常解释
println("num: "+num)
}
//隐式转换函数
//隐式转换函数是以implicit关键字声明的带有单个参数的函数
//这种函数将会在某个时刻下自动运行，将某个值从一种类型转换为另一种类型
//注：隐式转换函数名可以是任意的
//隐式转换函数与函数名无关，只有函数签名（函数参数类型和返回值类型）有关
//隐式函数可以有多个，但要保证在当前作用域，只有一个隐式函数被识别

隐式值（隐式值又叫隐式变量，即由implicit修饰的变量，编译器会在方法参数缺省的情况下搜索，同一作用域的隐式值作为缺省参数）

class ImlicitValue{

  def test1(implicit value: String): Unit = {
println("test1 value: " + value)
  }

  def test2(implicit value: String):Unit = {
println("test2 value: " + value)
  }
}

object ImplicitValue {
  implicit val implicitValue: String = "implicit value"

  def main(args: Array[String]): Unit = {
val iv = new ImplicitValue
iv.test1
iv.test2
  }
}

Scala中的Actor

什么是Actor
一个actor是一个容器，它包含状态，行为，信箱，子Actor 和监管策略，所有这些包含在一个ActorReference（Actor引用）里。一个actor需要与外界隔离才能从actor模型中获益，所以actor是以actor引用的形式展现给外界的。

Actor 简单实现

//创建Actor
import scala.actors.Actor

class MessageActor extends Actor {
  override def act(): Unit = {
for (i <- 1 to 5) {
  println("i: " + i)
  Thread.sleep(1000)
}
  }
}

//启动Actor
object MessageActorTest{
  def main(args: Array[String]): Unit = {
val messageActor = new MessageActor
messageActor.start()
  }
}

Actor消息发送

//消息类定义
import scala.actors.Actor

class HelloActor extends Actor {
  override def act(): Unit = {
while (true) {
  receive {
    case msg: String =>
      println("Hello " + msg)
    case msg: Int =>
      println("Your choose " + msg)
    case _ =>
      println("byte")
  }
}
  }
}

//消息发送
object HelloActorTest {
  def main(args: Array[String]): Unit = {
val helloActor = new HelloActor
helloActor.start()

helloActor | "scala"
helloActor | 1020
  }
}

LAllenKing

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Scala深度学习2

day02scala中的抽象类abstract class Father(newName:String) { protected var name:String=newName //抽象方法 def eat(food:String):Unit //普通方法 def run():Unit={println(this.name+"is running...") }...
复制链接

扫一扫