Scala使用

Scala数据类型、操作符、基本使用

1.概述

Scala是一门主要以Java虚拟机(JVM)为目标运行环境并将面向对象和函数式编程语言的最佳特性综合在一起的编程语言。你可以使用Scala编写出更加精简的程序,同时充分利用并发的威力。由于Scala默认运行于JVM之上,因此 它可以访问任何Java类库并且与Java框架进行互操作,比如Scala可以被编译成JavaScript代码,让我们更便捷、高效地开发Web应用。

Scala解释器读到一个表达式,对它进行求值,将它打印出来,接着再继续读下一个表达式。 这个过程被称作“读取-求值-打印”循环(read-­eval-print loop),即REPL。

2. Scala基础

  • Scala有两种变量,val和var,val类似于Java中的final
//age可修改、name不可修改
var age = 18
val name = "Tom"
  • 指定变量类型(默认情况下Scala会自己识别)
var age:int = 18
var name:String = "Alice"

3.基本类型&&操作

基础类型

Scala可以兼容Java中的类型,所以字符串类型用的依然是java.lang.String,其他类型均为Scala自己的成员

类型转换

操作符&&方法

1 + 1 =2
(1).+(1)=2

在Scala中任何操作符均为函数,即可调用,也可当做操作符使用

对象相等

由上可知,Scala中所有的操作符均为函数,所以与Java不同的在与,Scala中没有equal函数,全由==!=代替

4.条件判断

单行if语句

var result=if (100>70) true else false
print(result)

多行if语句

if (100>70){
    var result = true
}else{
    var result = false
}

5. 循环

while循环

var count = 0
while(count < 10){
    count += 1
}

do-while

var count=0
do{
count+=1
println(count)
}while(count<10)

for 循环(单行)

val arr = Array(1,2,3,4,5)
for(obj <- arr) println("obj:" + obj)

for循环(多行)

val arr = Array(1,2,3,4,5)
for(obj <- arr){
  println("obj:" + obj)
}

函数式

val arr = Array(1,2,3,4,5)
//逐步省略,Scala会自动识别
arr.foreach((x:Int) => println(x))
//省略类型
arr.foreach(x => println(x))
//省略参数
arr.foreach(println(_))
//省略括号
arr.foreach(println)

Range

//输出 1-10
for(i<- 0 to 10) println i
//输出 1-9
for(i<- 0 until 10) println i

Filter

// 输出 偶数
for(i<- 0 to 10 if i % 2 == 0) println(i)

yield

// 相当于Python中的生成器
val result = for(x<- 0 to 10) yield x*2
result.foreach(println)

lazy

// 懒加载,只有在file被使用时才回去加载资源
lazy val file =new File("demo.txt")
file.mkString

匹配表达式

//相当于Java中的Switch
val choice = "1"
choice match{
    case "1" => println("选择的是 :1")
    case "2" => println("选择的是 :2")
    case _ => println("选择的是 :其他")
}

6. 函数

Unit函数

// Unit 相当于Java 中的Void
def main(args: Array[String]): Unit = {
	println("Hello World")
}

单行函数

def demo1(id:Int):String = "my id:"+id.toString

头等函数(匿名函数|单行)

val dou = (x:Int) => x*x
println(dou(5))

头等函数 (多行)

val mul = (x:Int,y:Int) =>{
	x*y
}
println(mul(2,3))

占位符用法

// 在一个方法中包含另一个方法,里面的方法如果参数只是用一次,则可以用`_`来代替
val arr = Array(1,2,3,4,5,6)
val mul = (x:Int,y:Int) =>{
    println(x,y)
    x*y
}
println(arr.reduce(mul(_,_)))

变长参数

def demo(id:Int,name:String,others:String*): Unit = {
	others.foreach(println)
}

7. 类&&对象

辅助构造器&主构造器

// 主构造器
class User(ids:Int) {
  private var id:Int= ids
  private var name:String= _
    
  //辅助构造器
  def this(id:Int,name:String){
    // 当存在主构造器时,辅助构造器可以配合主构造器一起使用
    this(id)
    this.name=name
  }

  override def toString: String = {
    "id:"+id + "\t name:"+name
  }
}

方法重写

override def toString: String = {
	name
}

先决条件

class User(ids:Int) {
  private var id:Int= ids
  private var name:String= _

  //先决条件,可以在参数设置之前进行判断
  require(id>18)

  def this(id:Int,name:String){
    this(id)
    this.name=name
  }
}

继承&&特质

继承和Java差不多,都是单继承,但是可以多实现,在scala里面没有接口,只有特质(Trait) 特质的定义除了使用trait关键字之外,与类无异

Object对象

在Java或C++中,通常会用到既有实例方法又有静态方法的类。在Scala中,可以通过类和与类同名的伴生对象来达到同样的目的。 类和它的伴生对象可以相互访问私有特性,但必须存在同一个源文件中

class User(ids:Int) {
  private var id:Int= ids
  private var name:String= "Tim"
}

object User{
  private var num:Int =0
  def getNum():Int={
    num+=1
    num
  }
}

数组操作

定长数组
//Array 使用()访问,而不是[]
//创建并初始化
var arr = Array(1,2,3,4,5)
//初始化数组
var arr = Array[String](10)
变长数组
import scala.collection.mutable.ArrayBuffer
//变长数组 跟Java ArrayList差不多
val arr = ArrayBuffer[Int](10)
arr+=10

映射(Map)

// 构建 映射
val m = Map("a"->10,"b"->12)
var userList:Map[String,String] = Map()
// 添加新的键值对
userList+=("a"-> "123")
userList("b")="333"
// 获取对应值
println(m.get("a"))
//便利 映射
m.keys.foreach(println)
m.values.foreach(println)
m.foreach(println)

元组

元组是不同类型值的集合,和Python一样不可修改

//初始化元组,不指定元组个数,Scala会自动识别
val t1=(1,2,3)
val t2=Tuple3(2,3,4)
//输出
println(t1._1,t1._2,t1._3)

样例类

快速建立一些简单的类

object Objects {
  case class Message(Content:String,Sender:Actor)
  case class User(userName:String,password:String)
  case class Message1(countent:String,flag:Boolean)
}

泛型

class Pair[K,V](val k:K,val v:V){
    var key=k
    var value=v
}

隐式转换

略…

Actor并发编程

Scala中的Actor是一种不共享数据,依赖于消息传递的一种并发编程模式,避免了死锁、资源争夺的情况。 Scala中的Actor会不断循环自己的邮箱,并通过receive偏函数进行消息的模式匹配并进行相应的处理。如果Actor A与Actor B需要相互通信,首先A要给B发送一个消息,B会有一个收件箱,然后B会不断循环自己的收件箱,若看见A发送的消息,B就会解析A的消息并执行,处理完后将结果以邮件的方式发送给A。

一个简单的Actor Demo
// 使用Actor只需要继承一个Actor类,并实现act()方法即可
class ActorDemo extends Actor{
  override def act(): Unit = {
    receive{
      case msg:String => println("Message: "+ msg)
    }
  }
}

//主类调用	
val a1=new ActorDemo
a1.start
a1 ! "Hello?"
两个Actor之间的交互
//只需要将需要交互的Actor在发送信息的时候带上自己即可
class ActorDemo1(name:String) extends Actor{
  override def act(): Unit = {
    while (true){
      receive{
        case Message(cont,send)=>{
          println(name+" receive message :"+ cont)
          val str = readLine(name+" send message : ")
          send ! Message(str,this)
        }
      }
    }
  }
}
//主类调用
val a2 = new ActorDemo1("小王")
val a3 = new ActorDemo1("小张")

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Tool之DKM

    DKM,就是Workbench里的Downloadable Kernel Module project,这种工程用于管理/构建系统内核空间里的应用模块

    Taishan3721
  • 聊聊sentinel的SentinelGatewayFilter

    Sentinel-1.6.2/sentinel-adapter/sentinel-spring-cloud-gateway-adapter/src/main/j...

    codecraft
  • Java面试必问,深入理解 ThreadLocal 实现原理与内存泄露

    在面试环节中,考察"ThreadLocal"也是面试官的家常便饭,所以对它理解透彻,是非常有必要的.

    用户2781897
  • 我最喜欢的Mybatis 3.5新特性!超实用!

    Mybatis 3.5 发布有段时间了,终于支持了 Optional ,这么实用的特性,竟然还没人安利……于是本文出现了。

    用户1516716
  • 为什么HotSpot有‘对象’,因为他会垃圾分类和回收

    想和HotSpot一样吗?安全的管理众多的对象,掌握着对象的生与死。前文我们了解了对象在内存中的整个生命周期的是什么样的,程序运行就要无限的创建对象,我们Jav...

    胖虎
  • 被问到的一些面试题

    李才哥
  • Java8新特性学习--函数式编程

    函数式编程并不是Java新提出的概念,其与指令编程相比,强调函数的计算比指令的计算更重要;与过程化编程相比,其中函数的计算可以随时调用。

    beifengtz
  • java8实战:使用流收集数据之toList、joining、groupBy(多字段分组)

    本文将从Collectos中构建收集器入手,详细介绍java8提供了哪些收集器,重点介绍:toList、toSet、toCollection、joining、g...

    beifengtz
  • 聊聊dubbo的DubboSwaggerService

    dubbo-2.7.2/dubbo-rpc/dubbo-rpc-rest/src/main/java/org/apache/dubbo/rpc/protocol...

    codecraft
  • JavaScript常用数组操作方法,包含ES6方法

    concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组,仅会返回被连接数组的一个副本。

    李才哥

扫码关注云+社区

领取腾讯云代金券