Scala_学习

下载
配置环境变量
cmd scala
安装 Scala Eclipse IDEA
package org.Scala.Test
object Hello{
def main(args:Array[String]):Unit={
println("Hello,World");
}
}

-----------------------------------------------
Scala语言具备编写对象和函数式两种编程范式
SBT:构建工具、依赖管理、编译等等
函数式编程思想

Scala的语言基础
object aaa {
println("Welcome to the Scala worksheet")
//---------
val a:Int=1
println(a)

var b:Int=2
var c=b+a
println(c)

val x = 10

val y:Int=20

x+y

var aa =200

aa = 300

aa

lazy val f = x * y

f*10

val z:Double =1
val zz:Float =2
val zzz:Long=3
var zzzz = 1.0

val m= true
val mm=false

val u:Unit=()
val uu =()

def foo() = throw new Exception("error occurred")

//---------
val name = "wanglukai"
s"My name is ${name}"


//---------
def hello(name:String):String={
s"wanglukai,${name}"
}
hello("wudi")

def hello2(name:String) ={
s"wanglukai,${name}"
}
hello("wudi")

//---------
def add(x:Int,y:Int) = x + y //只有一个返回的话，代码块可以被省略
add(1,2)

//---------
if(true) 1 else 2
if(false) 3 else 4

val p =1
if(p == 1) p
if(p != 1) "not one"
if(p != 1) "not one" else p


//---------
val o = List("alice","bob","cathy")
for(
s<- o
)println(s)
for{
s<-o
if(s.length >3)
}println(s)
val result_for = for{
s<-o
s1 = s.toUpperCase()
if(s1 != "")
}yield(s)

//---------
try{
Integer.parseInt("dog")
}catch{
case _ => 0
}finally{
println("always be printed");
}

//---------
val code = 1
code match{
case 1 => "one"
case 2 => "two"
case _ => "others"
}

//---------
//求值策略
def foo(x:Int) = x
def foo(x: => Int) =x

//---------
def test1(x:Int,y:Int):Int= x*x
test1(3+4,8)

//def test1(x:=>Int,y:=>Int):Int= x*x
//test2(3+4,8)

//def bar(x:Int,y:=>Int) =1
//def loop():Int = loop //递归函数
//bar(1,loop)
//bar(loop,1)

//---------
def add(x:Int)(y:Int) =x+y
add(2,2);
}
三种变量修饰符
val 常亮
var 变量
lazy val 惰性求值的常量 如果定义的变量在后续的使用不会用到，可以定义
*可以不显示指定变量的类型，因为Scala会自动进行类型推导

Scala数据类型
Any
AnyVal 值类型
Numeric types
Boolean
Char
Unit
AnyRef 引用类型
All java.*
ref types

All scala.*
ref types
Null 引用类型最后一个子类
Nothing 值类型和引用类型最后一个子类

String:构建与Java的String之上,新增了字符串插值(interpolation)的特性
语法：var name = "wanglukai"
s"My name is ${name}"

代码块组织多个表达式、而代码块也是一个表达式：
语法：{exp1;exp2}
{
exp1
exp2
}
Block也是表达式，其最终的求得的值是最后一个表达式的值
函数：
语法：def funcationName(param:ParamType):ReturnType={

}
if表达式 而不是语句
语法：if(logical_exp) valA else valB

for表达式语法：for{
x<- xs
y= x+1
if(y>0)
}yield y
tyr表达式try{
Integer.parseInt("dog")
}catch{
case _=> 0
}finally{
println("always be printed");
}

match表达式，类似Java swich
code match{
case 1 => "one"
case 2 => "two"
case _ => "others"
}

求值策略
Scala里有两种求值策略
Call By Value 对函数实参求值，且仅求值一次
Call By Name 函数实参每次在函数体内被用到时会求值

Scala通常使用Call By Value
如果函数形参类型以 => 开头，会使用 Call By Value
//求值策略
def foo(x:Int) = x
def foo(x: => Int) =x

def test1(x:Int,y:Int):Int= x*x
test1(3+4,8)

//def test1(x:=>Int,y:=>Int):Int= x*x
//test2(3+4,8)

//def bar(x:Int,y:=>Int) =1
//def loop():Int = loop //递归函数
//bar(1,loop)
//bar(loop,1)

高阶函数
函数式第一等公民
Scala语言支持
把函数作为实参传递给另一个函数
把函数作为返回值
把函数赋值给变量
把函数存储在数据结构里
在Scala中，函数就像普通变量一样，同样也具有函数的类型。

函数的类型
Int => String 是把整形映射为字符串的函数类型

高阶函数：用函数作为形参或返回值，成为高阶函数
def operate(f:(Int,Int) => Int)={
f(4,4)
}
匿名函数：就是函数常常量
(形参列表) => {函数体}
def greeting() = (name:String) => {"hello"+""+name}

柯里化函数：把具有多个参数的函数转换为一条函数链，每个节点上是单一参数
例子：一下两个add函数定义是等价的
def add(x:Int,y:Int) = x+y
def add(x:Int)(y:Int) =x+y
add(2,2);

val addOne = add(1)_
addOne(2)

递归函数：在函数式编程中是实现循环的一种技术，因为在函数式编程中没有循环？？？
例子：计算n!
def factorial(n:Int):Int =
if(n <= 0) 1
else n * factorial(n - 1)

递归函数优化方案、尾递归：避免堆栈溢出

尾递归函数：中所有递归形式的调用都出现在函数的末尾。
当编译器检测到一个函数调用是尾递归的时候，它就覆盖当前的活动记录而不是在栈中去创建一个新的。
例子：@annotation.tailrec 对尾递归优化
def factorial(n:Int,m:Int):Int=
if(n <=0 )m
else factorial(n - 1,m * n)

factorial(5,1)

例子：
def sum(f:Int => Int)(a:Int)(b:Int):Int={

@annotation.tailrec
def loop(n:Int,acc:Int):Int={
if(n > b){
println(s"n=${n},acc=${acc}")
acc
}else {
println(s"n=${n},acc=${acc}")
loop(n+1，acc+f(n))
}
}
loop(a,0)
}
sum(x => x)(1)(5)
sum(x => x * x)(1)(5)
sum(x => x * x *x)(1)(5)
val sumSquare = sum(x => x * x)
sumSquare(1)(5)

Scala Immutable Collection

Collections-list基本使用
List[T] :T类型，Scala有类型推导、不写也罢
val a = List(1,2,3,4)
val b = 0 :: a
var c = "x" :: "y" :: "z" :: Nil

"z" :: Nil
"y" :: res0
"x" :: res1
val d = a ::: c //连接操作符

a.head //访问元素(方法)
b.head
c.head
a.tail //返回除了第一个元素的所有元素
c.tail
a.isEmpty //判断函数、判断List是不是空
Nil.isEmpty

def walkthru(l:List[Int]):String = {
if(l.isEmpty) ""
else l.head.toString + " " + walkthru(l.tail)
}
walkthru(a)

list高级使用

a.filter(x => x % 2 == 1) //参数是匿名函数

"99 Red Balloons".toList
"99 Red Balloons".toList.filter(x => Character.isDigit(x))
"99 Red Balloons".toList.takeWhile(x => x != 'B')

list-map

c.map(x => x.toUppercase) //大写
c.map(_.toUppercase) //_用于通配
a.filter(_ % 2 == 1)
a.filter(_ % 2 == 1).map(_ + 10)

val q = List(a,List(4,5,6))//拿出偶数
q.map(x => x.filter( _ % 2 == 0)）
q.map( _.filter( _ % 2 ==0))
q.flatMap( _.filter( _ % 2 ==0))
reduceLeft与flodLeft

a.reduceLeft((x,y) => x + y)
a.reduceLeft(_ + _)

a.foldLeft(0)(_ + _) 比前者通用
a.foldLeft(1)(_ * _)

Rang与Stream

Rang:1 to 10
1 to 10 by 2
(1 to 10).toList
1 until 10
Stream:
1 #:: 2 #::3 #:: Stream.empty
val stream = (1 to 10000).toStream
stream.head //访问
stream.tail
toupe与map
Tuple: //元组
(1,2)
1 -> 2
val t =(1,"Alice","Math",95.5)
t._1 //访问
t._2
t._3
t._4
def sumSq(in : List[Int]):(Int,Int,Int) =
in.foldLeft((0,0,0))((t,v) => (t._1 +1,t._2 +v,t._3 +v*v))
sumSq(a)

Map[K,V]
val p = Map(1 -> "David",9 -> "Elwood")
p(1) //取值
p(9)
p.contains(1) //判断有没有
p.contains(2)
p.keys //查询所有K
p.values //查询所有V
p + (8 -> "Archer") //添加
p _ 1 //删除
p ++ List(2 -> "Alice", 5 -> "Bob")//添加多个
p -- List(1,9,2)//删除多个
p ++ List(2 -> "Alice", 5 -> -- List(9,1)

实现快速排序

def qSort(a:List[Int]):List[Int] =
if(a.length < 2) a
else
qSort(a.filter( _ < a.head)) ++
a.filter( _ == a.head) ++
qSort(a.filter( _ > a.head)) //> qSort: (a: List[Int])List[Int]

qSort(List(3,1,2)) //> res0: List[Int] = List(1, 2, 3)
qSort(List(9,3,2,1,4,7,8,5)) //> res1: List[Int] = List(1, 2, 3, 4, 5, 7, 8, 9)

只是大致认知，还不算入门！！！
----------------------------------------------------

初始Scala
了解Scala是什么，学习Scala的意义何在，Scala安装，快速入门，
Scala与Java开发对比。

Scala入门
掌握Scala变量与常亮，数据类型，lazy的使用，Scala开发IDEA的使用，
IDEA整合Maven搭建Scala程序开发环境。

Scala函数
掌握函数在Scala中的定义以及使用的注意事项，条件以及循环表达式在Scala中的使用。

Scala对象
Scala中的重中之重，务必要掌握，
涉及到的内容有：类、构造器、继承、重写抽象类、“伴生类”以及“伴生对象”，
apply方式的使用、case class以及trait。

Scala集合
掌握Scala中的数组、List、Set、Map、Tuple、Option的使用

Scala模式匹配
掌握Scala中的模式匹配：基本、Array、类型、case class、Option的模式匹配、Scala中异常处理

Scala函数高级操作
掌握Scala中字符串的高级操作、匿名函数、偏函数、高阶高数的使用(重点)

Scala隐式转换
这是Scala中的亮点所在、也是最难理解的部分

Scala操作外部数据
使用Scala读写文本文件、网络数据、MySQL数据以及XML文件

项目实战
综合Scala前面的知识点、结合项目并整合SpringBoot进行项目实战