SCALA基础

面向对象和面向函数的集成

!!!!一切值都是对象，一切函数都是值!!!!
函数时编程，一切都是函数
数学式的语法思维

——————————————————————

IDEA开发环境准备：

1、安装JDK、SCALA环境

2、IDEA安装scala插件

3、创建maven工程，创建目录，设置为root source目录

4、创建文件，后缀为scala

5、scala可以直接与java交互

——————————————————————

[TOC]

——————————————————————

1、标识符

字母数字标识符：使用字母或者下划线开头，$符号在SCALA中也被看做是字母，但应该尽量避免定义$开头的变量，因为SCALA存在保留变量以$开头
符号：符号标识符包含一个或多个表示符，SCALA编译时会将符号转换为$开头的变量名，如:->会被转义为$column$minus$greater，可以看出会转义为$英文单词，因此在java中调用scala程序时要使用转义后的符号

2、import导包

SCALA的import可以出现在任何地方，有效范围：从声明处开始到程序最后结束。
SCALA会默认导入java.lang._ ，scala._包，因此以scala开头的包使用时会省略包名的引用。

3、变量与常量

vaR定义变量
- 变量定义时必须赋值：var A:Int =1
- 变量定义的类型可以不指定，自动推断
- 变量空值是_下划线,定义为空值时必须指定类型：var A:Char=_
（boolean空为false，数值空为0，字符空为？）
vaL定义常量
- val和def都可以定义常量，但val只初始化一次，def每次都会初始化
- 常量的引用地址是不可改变的
- 因为只是一层引用地址，因此使用复合类型的常量时，复合类型内部的值是可变的。

变量类型与java基本相同，但是SCALA中没有primitive基本类型，所有的值也都是对象，可以理解为只有包装类。

emmmm ，还支持很奇怪的多行字符串 """i am multiparaph string"""

4、变量类型结构

Any 顶级类型
- AnyVal
  - Unit
  - Byte、Short、Int、Long、Float、Double、Char、Boolean
  - 空值：Nothing
- AnyRef（java.lang.Object）
  - List
  - Option
  - MyClass
  - 空值：Null

5、类型别名

type关键字，type 别名=类型，类似C语言中的typedef typedef sturct{}mystruct stu

——————————————————————————————

流程语句语法

1、while循环

var i:Int=0;
while(i<100){
    println(i)
    i=i+1
}
do{
    println(i)
    i=i+1
}while(i<200)

2、for循环

val length：Int=100
for(i:Int <- 1 to length){
    println(i*100)
}
for(i:Int <- 1 to(length,step)){
    ...
}
for(i:Int <- 1 to length by step)){
    ...
}
for(i:Int <- 1 until length){
    println(i*100)
}
for(i <- 1 until(length,step)){
    ...
}
//until 和 to 都是一种函数，也可以通过i.until(length)调用
//until 和 to 创建的区间是相同的

3、中断break和breakable

关于Break和Continue，要导入包才可以使用

impot import scala.util.control.Breaks.break
impot import scala.util.control.Breaks.breakable

breakable(语句块)，内部嵌套break即可跳出本次循环
卸载breakable外面的break直接跳出循环
breakable即可打断的语句块，相当于在循环中又嵌套了一层可被打断的语句块，将代码写在其中即可实现continue

4、多条件循环

多重循环条件+分号;

val num:Int = 10;
for ( i: Int <- 1 to 10; if i%2==0;if i>5 ) 
{     
    println( i * 100 );
}yield i;
//使用 yield 将fot将具有返回值，yield中记录的是符合条件的步变量i的值的集合。
//可以看出for也是个函数

5、数组

泛型定义，中括号（java是尖括号）

数组，取值用小括号（java是中括号）

Array 不可变集合，元素内容可变，数组长度不可变

ArrayBuffer 可变长数组

万物皆函数，因此数组也是使用的小括号()
定长数组

//方式1
var a：Array[String]=new Array[String](3)
a(0)="hello"
a(1)="scala"
a(2)="world"
//方式2
var a2=Array("hello","scala")
//方式三，区间数组
var a3=Array.range(1,10,2)
//1，3,5,7,9

变长数组

import scala.collection.mutable.ArrayBuffer
var arrbuf:ArrayBuffer[String]=new ArrayBuffer[String]

6、元组

Tuple可以包含不同类型的值，类型以实际存储的元素类型为准
元组最多支持22个元素
使用name._1访问name元组的第1个元素，元祖没有0号位
元组的类型：元组的实际类型取决于它的分量的类型，比如的(2,"string")类型实际为 Tuple2[Int,String]，而 (‘u’,’r’,”the”,1,4,”me”) 的类型为 Tuple6[Char,Char,String,Int,Int,String]

Tuple[长度]（类型列表）

//元组声明方式一
var tp1 = ("Mike", "123 ABC street", 58)
println(tp1._1)
println(tp1._2)
println(tp1._3)
//迭代元组
tp1.productIterator.foreach{ i =>println("Value = " + i )}
//元组声明方式二
var tp2 = new Tuple3("Mike", "123 ABC street", 58)


//元组声明方式三
def mike = "Mike" -> 5   //键值对形式
//输出scala.Tuple2
mike.getClass
//将元组元素依次赋给三个变量
val(name, address, age) = tp1
println(name)
println(adrress)
println(age)

//元祖还可以这么玩
var yz=(1,List(2,3),"xixi")
val (id,order_id,name)=yz
//有点类似于样例类

1564123476174

7、集合Collection

1564023256574

1564023499099

1、序列Seq:List,Stack,Queue,Array

2、集合Set

3、映射Map

8、mutable和immutable不可变集合

复杂类型大都分为两类，MUTABLE和IMMUTABLE，可变的和不可变的，如ArrayBuffer就是一个可变集合，默认scala会选择不可变集合

包名：scala.collection.mutable|immutable.
可变集合：可以修改、添加或移除一个集合的元素

名称	可变/不可变	示例
Buffer	mutable	val buffer = scala.collection.mutable.ArrayBufferInt; buffer+=(2,3)
Array	mutable	val arr=Array(1,2,3)
List	immutable	val lst=List(1,2,3)
Map	mutable	val stu= Map("name" -> "Jason", "age" -> "18")
Set	mutable/immutable	val set=Set(1,2,3)
Vector	immutable	val v=Vector(1, 3, 5, 7, 11, 13)
Stack	mutable/immutable	val st=scala.collection.mutable.Stack(1,2,3) //堆栈，先进后出
Queue	mutable/immutable	val q=scala.collection.mutable.Queue(1,2,3) //队列，先进先出
BitSet	mutable/immutable	val bit=scala.collection.mutable.BitSet(3,2,0) //位集合
ListMap	immutable	val map = scala.collection.immutable.ListMap(1->"one", 2->"two")
HashSet	mutable	val set= scala.collection.mutable.HashSet(1,2,3)
HashMap	mutable	val stu= scala.collection.mutable.HashMap("name" -> "Jason", "age" -> "18")

9、集合常用操作

1）List常用操作

追加操作（新对象）
- 用于不可变对象，会生成新对象：
- +: 新加变量为主，在新变量后追加整个集合
- :+ 集合为主，在集合的后面追加新变量
扩充操作（本对象）
- 用于可变对象，直接修改本list:
- += 集合为主，在集合后面追加新变量
- +=: 新加变量为主，在集合的前面追加新变量
- ++=: 新加变量为主且该变量为List类型，在集合的前面追加新变量
分组操作
- grouped n（等价于list.grouped(n)），n个为一组
- sliding(n，step)，每次显示n个，，起始位置s是0。滚动显示，默认步长step为1

2）Set常用操作

SortSet ，可以排序的set
Set，去重的
增删操作
- += 修改自身，追加一个内容
- -= 修改自身，删除一个内容
- -- 删除一系列内容
- ++ 增加一系列内容
逻辑运算
- | 求并集intersect
- & 求交集union
- &~ 求差集diff

3）Map常用操作

4）Stream&Vector

Stream是惰性List，参数值只会在使用到的时候才会初始化
Vector是连续存储的List，访问效率比随机存储的list更高

10、空值

Nil 继承了List[Nothing类]，指空List
None 继承了Option[Nothing] 类，指的是Option的空值
Null是指空引用类型，null是引用的空值
Nothing 是Any的子类的，代表类型的的空（指没有类型，Null空类型也是一种类型），类型为空的变量必须是空的，没有实例

函数

一切函数都是值，一切值都是对象，一切对象都可以是函数

def 函数名([参数列表]):[返回值类型]={
    print("我是个函数")
    return [表达式]  
    //return 是可选的，如果不定义，自动返回最后一个行的值
}

1）函数调用

传值参数

//假设调用时为square(1+2)
def square(x:Int):Int={
    print(x) //3
    x*x //3*3
}

传名调用,x不计算，仅传递代码体
- 与闭包搭配，外面修改x后，函数每次都会重新计算参数值因此会实时更新X
```
def square(x: => Int):Int={  //注意空格
    print(x) //1+2，在print中计算
    x*x //（1+2）*(1+2)
}
```

！！！一切皆地址，函数也是地址，函数名只是引用的函数地址！！！

2)函数参数/函数返回值

语法结构：

def 函数名(形参名:（形参函数参数类型表）=> 形参函数返回值类型）：[返回值]={
	//调用形参函数
    形参函数名(参数)
}

demo实例

def myfun(fun:Int => Unit):Unit={
    fun(1)//注意，这里的fun是形参函数名
}
def fun(x:Int):Unit={
    print(x)
}
myfun(fun(1))
//：Unit 可以省略 ，默认就是无返回值

//参数为空
def NullPara(){}
或者
def NullPara(null: =>String):String{}//省略了类型

//常用高阶函数
val l=List(1, 2, 3, 4, 5, 6, 7, 8, 9)
l.map(_*2).foreach(println)
l.map(_*2).filter(_>8).foreach(println)l.fold(0)((sum,i)=>sum+i)
l.take(4).foreach(println)//非高阶
println(l.reduce(_+_))
println(l.reduce(_-_))
println(l.max)
println(l.count(_>3))
println(l.min)
println(l.sum)

val a=List(1,2,3,4)
val b=List("A","B","C","D")
println(a zip b)
val c=List("A","B","C","D","E")
println(a zip c)
val d=List(1,2,3,4,5)
println(d zip c)
List("zhangsan","lisi","wangwu").zip(List(100,90,75,83))

val f=List(List(1,2),List(3,4),List(5,6))
println(f.flatten)
println(f.flatMap(_.map(_*2)))

3)匿名函数

关键字符：=>
左边为（函数参数），右边为{ 函数体 }

(x:Int)=>{print(x)}
//因为匿名，没有引用变量，没法直接使用，要么赋值给变量，要么作为实参

myfun((x:Int)=>{print(x);print(x+x)})
//一般使用在函数参数处
//多条语句使用分号隔开

scala内置的大部分接口函数都支持匿名函数，可以自定义匿名函数作为foreach和map函数的参数

4）函数变量& def关键字

a）函数变量

//函数有参时
var funVar=myfun _  //相当于引用了函数地址
var funvalue=myfun  //报错
def funbody=myfun _	//相当于重名名函数
//使用下划线缺省函数参数
//可以说val其实是拿到了函数de返回值

//函数无参时
var funvar=myfun  //无参myfun等价于myfun()，执行函数并返回值给funvar

funVar("xixi")

var或者val定义的函数变量：定义时执行一次函数体，之后每次调用只能得到函数体的返回值return值
def定义的函数变量：定义时不执行函数体，之后每次调用都会完整的运行一遍函数体。

b）def关键字

def不仅仅用于定义函数和函数变量

5）嵌套函数

函数中可以再次定义函数，这个子函数只有在本函数内可见。

def factorial(i: Int): Int = {
      def fact(i: Int, accumulator: Int): Int = {
         if (i <= 1)
            accumulator
         else
            fact(i - 1, i * accumulator)
      }
      fact(i, 1)	//不能在factorial()之外调用
   }

6）cury柯里化

demo实例

def sum(x:Int)(y:Int)={
    print(x+y)
}

柯里化是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。

子函数依次产生，每个子函数根据当前参数返回新的子函数。
参数1--->子函数1(参数2)--->子函数2(参数3) >>>>>最终返回函数的最终返回值
更加灵活的调用同一个函数

灵活运用demo

def sum(x:Int)(y:Int)={
    print(x+y)
}
def f1(x:Int)=sum(1)(x)
def f2(y:Int)=sum(x)(2)
def f3(z:Int)=sum(3)_
def f4(g:Int)=sum_(4)
def f5(()()=>)

7）隐式函数/隐式参数

demo参数

implict var today="2018-10-25"
def mkLog(arg:String,implict date:String){
 	print(date+" "+arg)
}
mkLog("Success") //运行成功，作用域内找到合适类型的参数，使用隐式参数
mkLog("Success","2018-1-1") //运行成功

demo 函数

"100"/10   //ERROR 类型错误
def String2Int(str:String)={
    str.toInt
}
"100"/10  //类型错误-->发现合适的类型转换函数-->调用-->隐式转换
res1:10

隐式转换和调用只会发生在发生类型错误的时候
两者都需要有implict声明
只能发生在当前作用域内进行值和函数的查找

8)命名参数&参数缺省值

命名参数：即在调用函数的时候声明值的形参名

def function(str1:String,str2:String){
    print(str1+str2)
}
function(str2="xixi",str1="haha");
//res1:hahaxixi

参数缺省值：即在定义函数的时候给出参数的default值

def sum（a:Int=1,b:Int=2）{
print(a+b)
}
sum()
//res1:3
//与命名参数一起使用更佳
sum(b=10)
//res2:11
sum(10)
//res3:12

常用高阶函数

高阶函数，以函数作为参数

————————————————————————————————

1、map

集合的函数映射，生成新的集合

2、foreach

相当于for循环内部函数体

3、filter

自定义函数过滤器

lst.filter((x:Int)=>x>50)
lst.filter(_>50)
//参数函数返回值为true的元素才会被保留

4、reduce

lst.reduce(_+_)
lst.reduce((x:Int,y:Int)=>{x+y})

5、fold

lst.fold(5)(_+_)
//与reduce相似，但有一个预先值作为第一个值

//foldRight 从右侧开始

6、zip

//类似于拉链，逐个嵌套
var lst2=lst.map(_*2)
lst1.zip(lst2)
//生成了键值对列表
//长度以最短的list为准

7、flatten

//将复杂类型的内部嵌套展开
//只保留最外层的复杂类型结构
var map1=lst.map(x=>List(x))
map1.flatten
map1.flatten(_.map(_*2))

8、flatMap

//先对子复杂结构进行map
//然后flatten各子元素map的结果
map1.flatMap(_.map(_*2))

SCALA基础

SCALA基础

!!!!一切值都是对象，一切函数都是值!!!!

1、标识符

2、import导包

3、变量与常量

4、变量类型结构

5、类型别名

流程语句语法

1、while循环

2、for循环

3、中断break和breakable

4、多条件循环

5、数组

6、元组

7、集合Collection

8、mutable和immutable不可变集合

9、集合常用操作

10、空值

函数

一切函数都是值，一切值都是对象，一切对象都可以是函数

1）函数调用

！！！一切皆地址，函数也是地址，函数名只是引用的函数地址！！！

2)函数参数/函数返回值

3)匿名函数

4）函数变量& def关键字

5）嵌套函数

6）cury柯里化

7）隐式函数/隐式参数

8)命名参数&参数缺省值

常用高阶函数