Scala语法介绍

----------目录---------------------------------------------------------

1.Scala简介和安装

2.Scala语法介绍

3.Scala的函数

4.Scala中的集合类型

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

Scala语法介绍

1、语法规则

    1.会将方法体的最后一行代码,当作返回值返回。

    2.scala每行后面不需要加“;”,

    3.如果一行中需要多条语句,则需要用“;”隔开。

    4.如果scala的方法体只有一行代码,则方法体可以省略。

    5.如果scala调用的方法只有一个参数,则.()可以省略。

    6.如果函数的方法体只有一行代码,则方法体{}可以省略。

    7.如果函数的参数类型可以被推断出来,则类型可以省略。

    8.如果函数的参数列表只有一个参数,则参数的括号可以省略。

2、声明标识符

1.变量

    var:用来声明一个变量,变量声明后,在程序执行过程中可以被修改。

示例:

  def main(args: Array[String]): Unit = {
    //三种变量赋值方式
    var var1 = 100;
    var var2: Int = 100;
    var var3: java.lang.String = "hello";
    //变量修改
    var2 = 200;
    var3 = "world";
  }

    注:scala可以自动根据值的类型推断变量/常量的类型,所以不写类型声明也可以。

2.常量

    val:用来声明一个常量,一旦被赋值就不能再进行修改。

    注:java中变量使用较多,但在scala里,常量使用较多,因为在线程并发时可以减少甚至杜绝多线程并发安全问题,所以scala特别适合于应用在处理高并发场景。

//声明常量
val v2=200

3.懒值 Lazy

    当val被声明为lazy时,它的初始化将被推迟,直到我们首次对它取值。懒值对于开销较大的初始化语句而言十分有用。

    lazy只能用于常量(val),不能用于变量(var)。

    正常情况下通过val和var定义的量都会直接分配空间,即使这个量要在很久以后才使用,这样就会造成内存空间白白被占用。

    这种情况下可以加上lazy关键字,延后变量/常量赋值的位置。这样直到后续真正用到这个量时才真正开辟空间赋值,减少了内存的浪费。

val name = "zhang"//直接分配空间 即使一时半会用不到
lazy val name = "zhang"//并不会立即分配空间 直到后续用到了才会分配

示例:

lazy val v2=100
//> v2: => Int
println(v2)
//> 100

3、数据类型

1.类型

    Scala的数据类型有以下9种:

    Byte、Short、Int、Long、Char、String、Float、Double、Boolean。

1>说明

    其中String处于java.lang包,其他的则处在scala包下。

    由于scala会自动导入java.lang和scala包所以这些类型可以在程序中直接使用。

    其实可以认为scala中并没有真正意义上的基本类型(如java中的基本类型),以上的九种基本类型其实也出在包下是一个类。

    在scala中以上基本数据类型区别于其他类的地方在于,他们的对象都已直接量的形式体现。

    以上基本数据类型的直接量和java中基本完全相同,不再复述。

    这九个类的直接量在需要时可以自动被转换为其对应的富包装类来调用,富包装类提供的额外方法。

    每种数据类型都提供了很多方法供调用,所以scala的数据类型不同于java的基本类型。

scala.runtime.RichByte

scala.runtime.RichShort

scala.runtime.RichInt

scala.runtime.RichLong

scala.runtime.RichChar

scala.runtime.RichString

scala.runtime.RichFloat

scala.runtime.RichDouble

scala.runtime.RichBoolean

2.字符串操作

    事实上Scala的String类就是Java的String类,所以可以直接调用Java里String的所有方法。

    由于Scala提供了隐式转换的方法,String类也拥有StringOps类中所有方法的访问权限,所以可以用这些方法做许多事情

    示例:

val v3="hello"
//针对字符串做了repeat操作
v3.*(2)
v3.split("l")
//去重
v3.distinct
//去除头n个元素
v3.drop(1)
//去除尾部n个元素
v3.dropRight(2)
//提取头n个元素
v3.take(1)
//提取尾部n个元素
v3.takeRight(2)
//filter 根据指定的原则做过滤,其他类型都适用
v3.filter{x=>x!='l'}
v3.contains("l")
v3.exists { x => x=='l' }
//返回头1个元素。相当于take(1)
v3.head
v3.last
//以指定字符分割
v3.mkString(",")
//反转
v3.reverse

3.三引号

Scala中存在一个特殊的符号——三引号,在三引号中的字符都是普通字符,不需要转义。

    当你在不确定这个字符是否需要转义的时候,都可以使用三引号来标注,这样就可以省去转义的麻烦。

val v14="hello\t1711"
//> v14  : String = hello 1711
//三引号的使用:三引号中没有转义都是普通字符
val v15="""hello\t1711"""
//> v15  : String = hello\t1711

4.大数操作

    针对大数的操作,Scala专门提供了一个BigInt对象。

val v3:BigInt=2
//> v3  : BigInt = 2
v3.pow(10)
//> res10: scala.math.BigInt = 1024

4、操作符

    scala中操作符即方法,方法即操作符。

    scala中的操作符其实是普通方法调用的另一种表现形式。对以上基本的运算符的使用其实就是隐含的在调用对应的方法。所以,可以认为scala中并没有传统意义上的操作符,所有的操作符都是方法,所有的方法也都可以像操作符一样去使用。

    scala在做运算时,如果以方法形式调用,则以方法顺序来执行。如果以操作符的形式来调用,则以操作符优先级的顺序调用,优先级同Java。

1.类型

    算数运算:+、-、*、/。

    关系运算:>、<、>=、<=。

    逻辑运算:&&、||、!。

    位运算:>>、>>>、<<、~、&、|、^。

    比较运算:==、!=。

    示例:

val v4=2.+(3).*(5)
//> v4  : Int = 25
val v5=2+3*5
//> v5  : Int = 17

2.优先级

    scala中,符号优先级从高到底:(*、/、%)、(+、-)、:、=!、(<、>)、&、^、|。

3.前缀操作符

    前缀操作符一共有4种,分别是:+(正)、-(负)、!(非)、~(反)。

1>使用方法

直接使用

    在需要是用前缀操作符的直接量前面加(空格)(符号)即可。

    示例:

//使用时需要前面加空格
val v6= -2
//> v6  : Int = -2
val v7= +2
//> v7  : Int = 2
val v8= !false
//> v8  : Boolean = true
val v9= ~0XFF
//> v9  : Int = -256

调用方法

    为了避免产生歧义,可以通过unary方法来使用。

    示例:

//为了避免歧义可以通过以下形式来使用
val v10=2.unary_-
//> v10  : Int = -2
val v11=2.unary_+
//> v11  : Int = 2
val v12=false.unary_!
//> v12  : Boolean = true
val v13=0XFF.unary_~
//> v13  : Int = -256

5、条件判断

1.if else

    if……else 判断

    if是具有返回值的,if判断后,将执行代码的最后一个表达式的值返回作为整个if执行后的结果。

    示例:

val a=5
//> a  : Int = 5
if(a>5){
  //println("big")
  "big"
}else{
  //println("small")
  "small"
}
//> res0: String = small
if(a>5)
  "big"
else
  "small"
//> res1: String = small
  val r2=if(a>5)"big"else"small"
//> r2  : String = small

2.match

    scala中的match类似于其他语言的switch。

    match case语句是有返回值。

    示例:

  val v1="bbb"
  v1 match{
   case "aaa"=>{println("1")}
   case "bbb"=>{println("2")}
   case _=>{println("3")}
  }
  val result=v1 match{
   case "aaa"=>{println("1");"1"}
   case "bbb"=>{println("2");"2"}
   case _=>{println("3");"3"}
  }

6、循环语句

1.while

    和java中用法相同,while无法控制返回值,或者说返回值是Unit,写成(),在scala中while比较少使用。

    示例:

val a1=Array(1,2,3,4,5)
var index=0
while(index<a1.length){
  println(a1(index))
  index+=1
}

2.for

    scala中的for要比java的for强大,使用很频繁,需要熟练掌握。

    for同while一样,无法控制返回值,或者说返回值是Unit,写成()。但是for()可以和yield{}配合使用,将for()每次循环结果存到一个Vector()中。

示例:

	for(i<-a1){
		println(i)
	}
	for(i<-a1)println(i)
	1.to(5)
	for(i<-1.to(5)){
		println(i)
	}
	for(i<-1.to(5))println(i)
	1 to 5
	for(i<-1 to 5)println(i)
	for(i<-1 to 5 by 2)println(i)
//scala的for循环里可以写条件判断语句
	for(i<-1 to 5;if i>3)println(i)
	//多个条件之间用;隔开
	for(i<-1 to 5;if i>3;if i%2==0)println(i)
	//打印99乘法表
	for(i<-1 to 9){
		for(j<-1 to i)print(i+"*"+j+"="+i*j+"\t")
		println()
	}
	for(a<-1 to 9;b<-1 to a;val s=if(b==a)"\r\n"else"\t")print(b+"*"+a+"="+a*b+s)
	//s函数搭配$可以实现拼接打印的效果
	for(a<-1 to 9;b<-1 to a;val s=if(b==a)"\r\n"else"\t")print(s"$b*$a=${b*a}$s")
//for yield可以返回一个新的集合
//scala的集合类型涵盖数组、链表、set、Map、Range、Tuple等
//for yield for循环遍历的是什么类型,返回的就是什么类型
	val a2=for(i<-a1)yield{i*2}	
	val l1=List(1,2,3)
	val l2=for(i<-l1)yield{i+1}	
	val m1=Map("k1"->1,"k2"->2)
	for(i<-m1)println(i)
	for((k,v)<-m1)println(v)
	for((m,n)<-m1)println(m)
	for((k,v)<-m1)println(s"$k:$v")
	for(i<-Array(1,2,3))yield i*2
	Array(1,2,3).map(_*2)	val nums=List(1,2,3,4).filter(_<4)

3.跳出循环

    scala中没有break和continue语句,需要通过另外的形式来实现。想要使用break,需要先导包。

    import util.control.Breaks._

示例:

import util.control.Breaks._

  //实现break效果,需要将for循环体写到breakable()里
  breakable(
	for(i<-1 to 10){
		if(i>8)break
		println(i)
	}
  )
  //实现continue
  for(i<-1 to 10){
  	breakable(
  		if(i==8)break
  		else println(i)
  	)
}

7、异常

1.try catch finally

    scala中继承了java的异常机制。

    示例:

	try{
		throw new RuntimeException("error")
	}catch{
		case t: NullPointerException =>{t.printStackTrace();println("null")}
		case t: Exception=>{t.printStackTrace();println("other")}
	}finally{
		println("end")
	}

上一篇:Scala简介和安装

下一篇:Scala的函数

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

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏点滴积累

geotrellis使用初探

最近,单位领导要求我研究一下geotrellis(GITHUB地址:https://github.com/geotrellis/geotrellis,官网htt...

47780
来自专栏点滴积累

geotrellis使用(六)Scala并发(并行)编程

      本文主要讲解Scala的并发(并行)编程,那么为什么题目概称geotrellis使用(六)呢,主要因为本系列讲解如何使用Geotrellis,具体前...

38750
来自专栏Windows Community

UWP 手绘视频创作工具技术分享系列 - SVG 的解析和绘制

本篇作为技术分享系列的第一篇,详细讲一下 SVG 的解析和绘制,这部分功能的研究和最终实现由团队的 @黄超超 同学负责,感谢提供技术文档和支持。  首先我们来看...

42490
来自专栏AI科技大本营的专栏

Python 为何能坐稳 AI 时代头牌语言

作者 | 子白 谁会成为AI 和大数据时代的第一开发语言?这本已是一个不需要争论的问题。如果说三年前,Matlab、Scala、R、Java 和 Python还...

51060
来自专栏点滴积累

一个程序员的思考

读书笔记系列链接地址http://www.cnblogs.com/shoufengwei/p/5714661.html。        最近被一件事情虐的不行...

36850
来自专栏大数据-Hadoop、Spark

Scala学习一

1.集合操作练习 //创建一个List val lst0 = List(1,7,9,8,0,3,5,4,6,2) //将lst0中每个元素乘以10后生成一个新的...

63060
来自专栏点滴积累

编程的思想性——议编程与“武功”的一致性

一、缘起        最近做了一件事情,将写好的scala程序中稍显混乱和不雅的代码进行了重构(系列博客见http://www.cnblogs.com/sho...

37250
来自专栏点滴积累

geotrellis使用(五)使用scala操作Accumulo

    要想搞明白Geotrellis的数据处理情况,首先要弄清楚数据的存放,Geotrellis将数据存放在Accumulo中。     Accumulo是一...

44540
来自专栏点滴积累

使用bokeh-scala进行数据可视化

目录 前言 bokeh简介及胡扯 bokeh-scala基本代码 我的封装 总结 一、前言        最近在使用spark集群以及geotrellis框架(...

66680
来自专栏点滴积累

使用bokeh-scala进行数据可视化(2)

目录 前言 几种高级可视化图表 总结 一、前言        之前已经简单介绍过一次如何使用Bokeh-scala进行数据可视化(见使用bokeh-scala进...

39270

扫码关注云+社区

领取腾讯云代金券

年度创作总结 领取年终奖励