上一篇文章介绍了如何下载scala, 因为在官网上点击下载按钮无法下载,

下面介绍scala的基础语法:

1 scala和java的关系

Scala是基于jvm的一门编程语言,Scala的代码最终会经过编译成字节码,交给java虚拟机来运行

Scala和java可以无缝互操作,Scala可以任意调用java代码、

2 Scala的解释器 repl

scala的解释器会快速编译scala代码为字节码然后交给jvm来执行。

repl :  read 取值 ---> evaluation 求值  ----> print 打印 ----> loop 循环

3 声明变量和常量和指定类型

声明变量使用 var  这个和 js类似

声明常量使用 val  声明常量赋值后  这个常量将不能再被改变值

定义中建议使用常量声明,类似于spark的大型复杂系统中,需要大量网络传输数据,如果使用var 可能会担心值被错误的更改,这个类似于java中使用final关键字来

提高系统健壮性一样。

eg:  var name:String = "zm"

var name1, name2:String = "zm"

4 数据类型和操作符

基本数据类型: Byte、Char、Short、Int、Long、Float、Double、Boolean。  和java的包装类型一致,没有基本数据类型

操作符: 和java的操作符一致, 唯一区别是 ++ --没有,  比如 a++ 必须写成 a += 1

5 函数调用

调用函数如果不需要传递参数 那么 scala 允许省略掉括号。

6 块表达式:

指的就是{}中的值, 最后一个语句的值就是块表达式的返回值。

eg:

var a = 1;
var b = 2;
var c = 3;
var d = if(a < 10) { b = b + 1; c + 1 }
println(d)
结果是4 也就是将 c+1的结果返回给了d

7 条件和循环案例:

/* if 案例
val age = 34;
if(age < 10) {
println("you are child")
}else{
println("you are adult")
}*/
// 块表达式
/* var a = 1;
var b = 2;
var c = 3;
var d = if(a < 10) { b = b + 1; c + 1 }
println(d)*/ // while 和java使用规则一样
/* var n = 10
while(n>0) {
println(n)
n -= 1
}*/ // for循环 scala只有如下这种形式的for写法
// 1 简易版的for
// var n=10; for(i<- 1 to n) println(i)
//for(c<-"hello world") println(c) // 跳出循环 scala没有类似java的break语句 但可使用 boolean变量 return或Breaks的break函数
/* import scala.util.control.Breaks._
breakable{
var n=10;
for(i<-1 to 10){
if(i==3) {
break;
}
println(i);
}
}*/ // 多重for
/* for(i<-1 to 9; j<-1 to 9){
println(i*j +" " )
}*/

8 定义函数:

定义函数的函数名、参数、函数体,返回值类型, 其中形参和返回值类型都使用 :类型 方式 , 如果函数有返回值 那么需要在形参定义完成后 在使用  = {函数体}

如果定义的函数名和函数体之间没有用 = 关联 那么默认返回值类型是Unit,并且定义的是一个过程而不是一个函数 过程通常用于不需要返回值的函数。

使用 def关键词定义, 注意 参数和函数体之间使用 = 来连接, 如果给默认参数赋初始值 需要在定义形参中里使用 = 赋值

  // 代码块中最后一行的返回值就是整个函数的返回值。与Java中不同,不是使用return返回值的。 不过使用 return 我试验了也没发现报错

  /*def sayHello(name:String):String ={
"hello " + name
}
var name = sayHello("zm")
println(name)*/
/*def fab(n:Int):Int={
if(n <=1) return 1
else return 3
}
var result = fab(5)
println(result)*/ // 给默认参数赋初始值
/* def sayHello(name:String, age:Int=32) = {
println(name + "| " + age)
}
sayHello("zm",34)
sayHello("zm")*/

9  函数可变参数 + 序列传递 + 递归函数写法

函数定义中 变长参数使用   形参定义后需要增加一个*表示可变参数

object ScalaExample {

  def main(args: Array[String]): Unit = {
// println(sum(1,2,3)) // 将已有序列直接调用变长参数函数, 需要使用特殊语法让scala解释器识别 ---》 :_*
//var result = sum(1 to 5:_*)
//println(result)
println(sum2( to :_*)) // 1 to 5表示序列 序列传递给可变参数的函数 } // 定义可变参数函数
def sum(nums:Int*)= {
var res = ;
for(num<-nums) {
res += num
}
res
}
// 定义递归函数
def sum2(nums:Int*) :Int={
if(nums.length==)
else nums.head + sum2(nums.tail:_*)
} }

10  过程  lazy值  异常

1 定义函数时,如果函数体直接包裹在了花括号里面,而没有使用=连接,则函数的返回值类型就是Unit。这样的函数就被称之为过程。过程通常用于不需要返回值的函数。

  // 过程是函数的一个子集  不需要使用 = 和函数体关联   表示没有返回值的函数
/*def sayHello(name:String){
println("hello: " + name)
}
var result = sayHello("zm")
println(result) // 结果是()*/ // 如果将一个变量生命为lazy //即使文件不存在,也不会报错,只有在第一个使用该变量时如果文件不存在才会报错,证明了表达式计算的lazy特性。
// 这种特性对于特别耗时的计算操作特别有用,比如打开文件进行IO,进行网络IO等
import scala.io.Source._
lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString // 异常的写法和Java很类似 例子如下 注意 catch 里面的写法 _: XXException => dosomething
try {
throw new IllegalArgumentException("x should not be negative")
} catch {
case _: IllegalArgumentException => println("Illegal Argument!")
} finally {
print("release resources!")
}

11 数组 和 遍历的集中方式

scala数组底层实际上是Java数组,比如scala的字符串数组在底层就是Java的String[] , 整数数组底层就是Java的Int[]

for遍历几个方式:  增强for循环   正常方式遍历   跳跃遍历   翻转遍历 , 定长变长数组定义和互换和变长数组增减元素写法

  // 定长数组  定义定长数组方式1
var a = new Array[Int]()
a() =
// 定义定长数组方式2
var b = Array(,,) // 定义变长数组
import scala.collection.mutable.ArrayBuffer
val b1 = new ArrayBuffer[Int]()
// 使用+=操作符,可以添加一个元素,或者多个元素
b1 +=
b1 += (,,,)
// 使用++=操作符,可以添加其他集合中的所有元素
b1 ++= Array(,,,,)
// for(c<-b1) println(c)
// 删除尾部的几个元素
b1.trimEnd()
// for(c<-b1) println(c)
// 添加元素
// 在index为5的位置上插入数字6
b1.insert(,) // 在index为5的位置上插入数字6
b1.insert(,, , , )// 在index为6的位置上插入数字 7,8,9,10
//for(c<-b1) println(c) // 增强for的遍历
//删除元素SW
b1.remove() // 移除掉index为1上的元素
//for(c<-b1) println(c) // 1 3 4 5 6 7 8 9 10
b1.remove(,) //移除掉index为1上包含index为1开始向后一致移除三个 1 6 7 8 9 10
// for(c<-b1) println(c)
//var d = b1.toArray // 变长数组转换为定长数组
//var c = b.toBuffer // 定长数组转换为变长数组
// 数组普通遍历
// for(i<- 0 until b1.length) println(b1(i))
// for(i<- 0 until (b1.length,2)) println(b1(i)) // 跳跃遍历 间隔两个 取第三个
//for(i<- (0 until b1.length).reverse) println(b1(i)) // 翻转遍历 间隔两个 取第三个
val a = Array(1,2,4,3,5)
val sum = a.sum // 求和
val max = a.max // 获取最大值 // 排序
scala.util.Sorting.quickSort(a)
print(a.mkString(",")) // 获取数组中所有元素内容指定间隔符间隔 1,2,3,4,5
// yield 根据条件选择构建数组
/*
对于for循环的每次迭代,yield都会生成一个将被记住的值。就像有一个你看不见的缓冲区,for循环的每一次迭代都会将另一个新的值添加到该缓冲区
当for循环结束运行时,它将返回所有已赋值的集合。返回的集合的类型与迭代产生的类型相同,因此Map会生成Map,List将生成List,等等。
另外请注意,最初的集合没有改变。for / yield构造根据您指定的算法创建一个新的集合。
* */
// var a = Array(1,2,3,4,5,6)
//var b = for(c<-a) yield c*2
// var b = for(c<-a if c%2==0) yield c*c // yield + for + if 组合筛选构建新数组 //var b = a.filter(_%2==0) // 2-4-6
// var b = a.filter(_%2==0).map(_*2) // 4-8-12 通过数组函数来 筛选和构建新数组
// println(b.mkString("-")) var a = ArrayBuffer(1,2,3,4,5,-8,-3,11,-5,-9)
/* var foundFirstNegative = false
val keepIndexes = for (i <- 0 until a.length if !foundFirstNegative || a(i) >= 0) yield {
if (a(i) < 0) foundFirstNegative = true
i
}
for (i <- 0 until keepIndexes.length) { a(i) = a(keepIndexes(i)) }
a.trimEnd(a.length - keepIndexes.length)
println(a.mkString("-"))
*/
// 遍历数组里所有元素,当找到第一个负数时 设置flag位 同时标注每个元素如果是大于0下的数组索引位置
/* var firstNagivate = false
var indexFlag = for(i<- 0 until a.length if(!firstNagivate || a(i) > 0)) yield {
if(a(i) < 0) firstNagivate = true
i
}*/
//println(indexFlag.mkString("-"))
/* for(i<- 0 until( indexFlag.length)) { // 将找到元素位置的数据重写到 原来数组中
a(i) = a(indexFlag(i))
}
a.trimEnd(a.length - indexFlag.length) // 将原来数组中不需要的数据截取掉
println(a.mkString("-"))*/
/* println("数组长度为: " + indexFlag.length)
var newA = new Array[Int](indexFlag.length)
for(i<- 0 until( indexFlag.length)) { // 将找到元素位置的数据重写到 新数组中
// newA(i+1) = a(indexFlag(i))
println(i+ " | "+ a(indexFlag(i)))
newA(i) = a(indexFlag(i))
}*/
 

12 Map 和 Tuple

  //map 学习
// 不可变map ()
val ages = Map("zm"->,"liangliang"->)
//ages("zm") = 31 不可以赋值修改
// 可变map
val ages1 = scala.collection.mutable.Map("zm"->,"liangliang"->)
//val ages2 = scala.collection.mutable.Map(("zm",32),("liangliang",31)) 或者这种方式定义
ages1("zm")= // 修改可变map的value值
// 创建空的map
//val ages2 = new mutable.HashMap[String,Int]
//val result = ages1.getOrElse("zm",42); // 获取map的key值
//println(result)
ages1 += ("yan"->,"mei"-> ) // 可变map增加元素
//ages1 -= "yan" // 可变map删除元素
// println(ages1.mkString(","))
/* val ages4 = Map("zm"->32) // 不可变map 增减元素是通过 + - 方式并构建一个新的map接受 可变map增减是通过 += -=方式但必须要构建新的map
val ages5 = ages4 + ("liang"->30)
//println(ages5.mkString(","))
val ages6 = ages5 - "liang"
println(ages6.mkString(","))*/
// map的遍历
//for((k,v)<-ages1) println(k+"," +v)
// val ages6 = for((k,v)<-ages1) yield(v,k) // 使用 yield构建新的map
//println(ages6.mkString(","))
//for(k<-ages1.keySet) println(k)
//for(v<-ages1.values) println(v)
// 对map的key进行排序 看了下 只有immutable包下有这个排序的方法 返回给一个新的map
// val ages7 = scala.collection.immutable.SortedMap("liang"->31,"ping"->29,"ming"->32)
// println(ages7.mkString(","))
//val ages8 = new scala.collection.mutable.LinkedHashMap[String,Int] // 按照插入顺序存放k-v 否则map的k是没有顺序的
//ages8("zm")=34 // 元组 tuple 在spark中有大量的tuple的使用,是一种很灵活的数据结构
val t = ("zm",)
//println(t._1)
val names = Array("zm","ping")
val age1s = Array(,)
val nameages = names.zip(age1s) // zip操作 替代了自定义javabean方式
for ((name, age) <- nameages) println(name + ": " + age)
// tuple ,就是由()包起来,和数据库中一条记录概念类似 ,或者理解为 是一个特殊类型的数组,数组中存储的是不同类型的值,一个元组中最多能存22个元素
var firstTuple = ("str",1,0.5)
println(firstTuple._1) // 返回 str 字符串 注意使用时不要写成按照 数组方式获取值了 这不是数组

Scala基础知识笔记1的更多相关文章

  1. Scala基础知识笔记2

    1 类 1.1 定义一个简单的类 1.2 field的getter 和 setter方法 感觉成员变量定义成  var 属性名=属性值即可,  不需要定义成 val 或者 private就行, // ...

  2. JS基础知识笔记

    2020-04-15 JS基础知识笔记 // new Boolean()传入的值与if判断一样 var test=new Boolean(); console.log(test); // false ...

  3. Java多线程基础知识笔记(持续更新)

    多线程基础知识笔记 一.线程 1.基本概念 程序(program):是为完成特定任务.用某种语言编写的一组指令的集合.即指一段静态的代码,静态对象. 进程(process):是程序的一次执行过程,或是 ...

  4. javascript基础知识笔记-自用

    笔记内容根据个人基础知识不足不明白之处做的记录.主要看的:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript 1.变量,变量的名字又叫标识符 ...

  5. Mysql之基础知识笔记

    Mysql数据库基础知识个人笔记 连接本地数据库: mysql -h localhost -u root -p 回车输入数据库密码 数据库的基础操作: 查看当前所有的数据库:show database ...

  6. java基础知识-笔记整理

    1.查看已安装jdk文件路径 CMD输入java -verbose.   2.java学习提升路线 java学习视屏地址: http://www.icoolxue.com/album/show/38 ...

  7. scala 基础知识总结

    在最开始处引入 log 相关的 包 import org.apache.log4j.{Logger,Level} 在需要屏蔽日志输出的地方加上这两行代码 // 屏蔽不必要的日志显示在终端上 Logge ...

  8. JavaScript基础知识笔记

    做前端几年了,一直疏于整理归纳,所以这两天把基础看了一遍,加上使用经验,整理了基础知识中关键技术,旨在系统性的学习和备忘.如果发现错误,请留言提示,谢谢! 重要说明:本文只列举基础知识点,中级和高级内 ...

  9. Scala基础知识[一]

    摘要:在Scala 是 Scalable Language 的简写,是一门多范式(multi-paradigm)的编程语言.设计初衷是要集成面向对象编程和函数式编程的各种特性.Scala 运行在Jav ...

随机推荐

  1. PAT——1026. 程序运行时间

    要获得一个C语言程序的运行时间,常用的方法是调用头文件time.h,其中提供了clock()函数,可以捕捉从程序开始运行到clock()被调用时所耗费的时间.这个时间单位是clock tick,即“时 ...

  2. linux 编译ffmpeg 支持x264, x265

    1. 前言 本教程涉及的ffmpeg, x264, x265 2. 环境依赖 2.1 删除系统中安装的ffmpeg等库 sudo apt-get --purge remove ffmpeg mplay ...

  3. Go语言之旅:包

    每个 Go 程序都是由一些包组成的. 原文地址:https://golang-book.readthedocs.io 欢迎关注我们的公众号:小菜学编程 (coding-fan) 程序从 main 包开 ...

  4. execute immediate

    首先在这里发发牢骚,指责下那些刻板的书写方式,不考虑读者理不理解,感觉就是给专业人员用来复习用的一样,没有前戏,直接就高潮,实在受不了!没基础或基础差的完全不知道发生了什么,一脸懵逼的看着,一星差评! ...

  5. Linux -- 目录基本操作(1)

    cd 切换目录 1.切换到指定目录下 #cd 相对/绝对目录 [root@localhost ~]# cd /home/tom/demo [root@localhost demo]# 2.切换到某个用 ...

  6. 有关集合的foreach循环里的add/remove

    转自:Hollis(微信号:hollischuang) 在阿里巴巴Java开发手册中,有这样一条规定: 但是手册中并没有给出具体原因,本文就来深入分析一下该规定背后的思考. 1 .foreach循环 ...

  7. ionic 环境搭建

    1.安装nodejs (8.4.0) 下载地址 https://nodejs.org/zh-cn/ 2.Java jdk  版本号  jdk1.8.0_121 3.安装 cordova npm ins ...

  8. HTML5常用标签及特殊字符表

    *http://html5doctor.com/nav*http://html5doctor.com/article*http://html5doctor.com/section*http://htm ...

  9. Delphi XE7的Splash 功能

    Delphi XE5,XE6,XE7编译的程序在Android下启动会有一段时间黑屏,以前需要用Java扩展Activity增加Splash显示, 现在Delphi XE7增加了Splash Imag ...

  10. Python调用time模块设置当前时间-指定时间

    import datetimeimport time#新建元旦时间#将程序打包def A(): # 设定时间 newyear =datetime.datetime(2033,10,1) #调用当前时间 ...