Scala入门基础

Scala入门 散装笔记

Scala是一门面向对象同时也是面向函数的编程语言。Scala运行在JVM环境，天然继承java的类库。

• 无缝集成java，兼容java的所有特性，并在java的基础上做优化
• 纯面向对象编程语言，一切皆对象，包括一个值
• 函数式编程，提供高阶函数，闭包、模式匹配、单一赋值等多种语法

笔记主要记录的是在Scala语言中与java的一些区别以及注意事项，很基础的就不会特别全面。

1 变量类型与数据结构

变量

分为可变类型（var）和不可变类型（val）。不可变类型在生命初始化后就不能再改变，属于全局静态变量。Scala属于函数式编程，所以倾向于使用不可变类型。

lazy关键字 这是一个值得关注的变量关键字，用于声明不可变类型初始化但是不赋值，在使用过程才会赋值。

scala> lazy  val testInt=9
testInt
testInt=10
testInt: Int = <lazy>

scala> res2: Int = 9

scala> <console>:12: error: reassignment to val
testInt=10

另外lazy不能描述var类型，因为要避免程序运行中var的值改变

基本数据类型

Scala有一个自动推导类型机制，在定义变量的时候可以不填类型，根据右边的初始值推断类型。因为在Scala中一切皆对象，所以与Java的区别是数据类型以大写开头。

Float与Double

在不填类型时，小数点默认是double型，定义浮点型可以在数值后面带上F/f

val floatnum=1.421f

String

String直接继承了Java.lang的String类，还有一些隐式转化。

Scala使用双引号包裹字符串，遇到符号需要用转义字符‘\’或者直接使用三个双引号原样输出字符串。

基本类型操作

包括算术运算符/关系运算符/逻辑运算符/位运算符/对象比较运算符/字符运算符

对象运算符

Scala中的对象比较不同于Java，Scala基于内容比较，而Java比较的是对象引用，即物理内存是否一致，在比较时需要定义比较方式。

字符串运算符

Scala继承Java.lang.String类型，可以调用String的所有方法。并且实现了String隐式转换StringOps对象，调用reverse(反转)、map(映射)、drop(删除)、slice(截取)等方法。

运算符优先级

优先级增加了一个右操作符(::构造/:::拼接)

优先级 高到低	符号及描述
1	* 、/、%
2	+、-
3	List ::构造、:::拼接,右操作
4	<=、>=、==、=、!、!=
5	<、>、<<、>>、<<<无符号左移、>>>无符号右移
6	& 位与、&&逻辑与
7	^位异或
8	|位或、||逻辑或

scala> 1*10-2::2+2::7::8::Nil:::List(1,2):::List(3,4)
res4: List[Int] = List(8, 4, 7, 8, 1, 2, 3, 4)

元组类型

元组是Scala中的特殊类型，可以保存不同类型的数据。数据访问通过 变量名_.N N表示第几个元素。

2 程序控制结构

if语句

基本用法一致，在Scala中if还可以当成表达式，函数返回值可以赋值给变量

scala> val x=if (2==8)true else false
x: Boolean = false

while循环语句

Scala弱化while，因为while的参数必须是var类型，函数式编程推荐使用for进行循环操作。

for循环语句

基础循环

Scala有自己独特风格的for语句

for (i<-表达式){
	//执行语句
}
scala> for (i <- 1 to 3) println("i="+i)
i=1
i=2
i=3

(<-)称为生成器(generator)，for遍历集合赋值给i。

Scala中for不支持break与continue关键字终止循环，要实现停止循环有两种方式:一种是设置Boolean类型变量终止循环条件；另外一种是引用Breaks类。

import scala.util.control.Breaks._
breakable{
  for (i<- 1 to 3){
    if(i==2)break()
    print(i)
  }
}

breakable与break()都是breaks类中的方法。

过滤循环

在for语句中加入限定条件，满足则执行语句。

for (i<- 1.to (6)if(i%2==1)) print(i)
1 3 5

3 集合

Scala集合分为可变集合与不可变集合。

可变集合 更新、删除、修改元素将作用于原集合。

不可变集合 一旦被创建原集合就不能改变，添加、删除、更新等操作返回的是新集合。

默认使用immutable不可变集合，使用可变集合需要导入可变集合包，在创建时定义为可变集合。

import scala.collection.mutable
val mutableSet=mutable.Set(1,2,3)

数组

分为定长数组与变长数组，定长数组在定义是被确认，变长数组可以随使用动态扩容。

定长数组

scala> val numberArray=new Array[Int](10)
numberArray(1)=89
numberArray(1)
numberArray: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala>
scala> res15: Int = 89

scala> val numberArray=new Array[Int](10)
val sumArray=new Array[Int](10)
numberArray=sumArray

numberArray: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
scala> sumArray: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> <console>:16: error: reassignment to val
       numberArray=sumArray

numberArray与sumArray都是val类型，意味着它指向的数组不能变，但是数组的内容可以变。

变长数组

scala> import scala.collection.mutable.ArrayBuffer
val ArrayVar=new ArrayBuffer[String]()

import scala.collection.mutable.ArrayBuffer

scala> ArrayVar: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer()

常用操作

//添加元素或者多个元素集合
ArrayVar+=6
ArrayVar+=(7,9)
//追加数组
ArrayVar++=Array(1,2,3)
//追加list
ArrayVar++=List(6,7)
//删除末尾N个数据
ArrayVar.trimEnd(N)
//插入元素
ArrayVar.inser(index,8,0)
//删除索引后的5个数据
ArrayVar.remove(index,5)
//定长与变长互转
ArrayVar.toArray
ArrayVar.toBuffer

数组遍历

通常采用数组下标的方式遍历

for（i<- 0 to ArrayVar.length-1){

}或
for（i<- 0 until ArrayVar.length){

}

推荐使用直接遍历数组

for (i<- ArrayVar){

}

多维数组

//定义2行3列
scala> val mularray=Array(Array(1,2,3),Array(4,5,6))
for(i<-mularray){println(i.mkString)}
mularray: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5, 6))

scala> 123
456

 

原文地址：https://blog.csdn.net/weixin_45075077/article/details/100034615