scala入门（一）

Scala语言：

• scala是一门以jvm为运行环境(scala文件会被编译器编程成.class文件运行在jvm上)的将面向对象和函数式编程（将电脑运算视为函数的计算）结合在一起的静态类型编程语言（ps：静态类型：编译时即知道每一个变量的类型，类型错误的话编译时报异常。动态类型：编译时不知道每一个变量的类型，类型错误的话运行时报异常）。

1、数据类型：byte、Char、short、int、long、float、double和boolean、unit类型。（unit表示无值，相当于void。只有一个实例值，写成()）
2、定义变量:var/val。
var name = “zhangsan”
val name: String = “zhangsan”
var和val的区别:val定义的相当于java中final修饰的常量，值只定义一次，后续无法改变。
3、输出：println()

1. 'f’是差之旗，允许创建一个格式化的字符。可用%d、%f等，类似于c语言printf
   print(f"$name:%s")
   printf("%s"，name)

2. ‘s’允许正在处理字符串时直接使用变量
   println(s"name=$name")//将变量name直接打印在字符串中s和f的区别是s中可以使用${}，括号里面可以是任意的表达式
   println(s"1 + 1 = $1+1")println(s"${对象.方法()}")

4、for循环:for(i <- 表达式/数组/集合)

1. 0 to 5 ：[0,5]
2. 0 until 5 : [0,5)
3. for (i <- arr if i % 2 == 0) {} //取集合中下标为偶数的值
4. for ()i <- 1 to 3; j <- 1 to 3 if i != j) {println((10 * i + j) + " ")} //双重for循
5. yield 产生新的集合。for循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。Scala中for循环是有返回值的。如果被循环的是Map，返回的就是Map，类推。

5、scala中±等操作符以及&|^等作用和java一致，但在scala中这些操作符是方法：a + b 是 a.+(b)的简写（a调用方法+()，b是传参）
6、方法: def 方法名(传参) ： 返回值类型 = 方法体

• 例如：def add(x : Int, y : Int) : Int = {x + y} // 其他方法可以不写返回值类型，编译器会自动推断，但是递归函数，必须指定返回值类型。

7、函数的两种定义方式:

• val add1 : (Int, Int) => Int = (x,y) => x+y
• val add = (x : Int, y : Int) => x+y
  8、传值调用和传名调用：

var count = 10 
def del() : Int = {count = count - 1} 
printByName(del)

• 传值调用

`def printByName(x : Int) = {for(a->0 to 3) {println(s"${x}")}

打印结果:
9
9
9
9
传值调用只会在方法调用，得到值。

• 传名调用

def printByName(x : => Int) = {for(a->0 to 3) {println(s"${x}")}

打印结果:
9
8
7
6
传名调用x:=>Int表示一个方法的签名 =>没有参数，返回值为Int的函数，作为参数，每次调用x都会执行一次函数。隐式将x转换成函数，将del的方法名称传递到方法的内部执行。传递的是一个引用。

8、可变参数:

def add(intValue: Int, ints : Int*) : Int = {var sum = intValue for(v <- ints){sum+=v} sum}

9、高阶函数：将其他函数作为参数或者其结果是函数的函数
10、柯里化：将入参为2个的函数变成入参为1个的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。函数经过柯里化后通用性降低，适用性提高。
11、偏函数：def method : partialFunction[参数类型,返回值类型] = {case => }
12、数组：

1. 定义: val arr = new ArrayInt 不可变数组：内容可变，长度不可变
   val arr1 = Array{1,2,3} //相当于Array.apply(1,2,3)
2. map(映射)方法：arr经过map操作后返回一个新的数组类型，本来arr的内部内容没有改变。例如：将数组里的元素都乘以10

 val arr = Array{1,3,5,7} 
 1、arr.map((x:Int)=>x*10) 
 2、arr.map(x=>x*10) 
 3、arr.map(_ * 10)

3. flatten(扁平化操作)：

 val arr = Array("hello world","word count") 
 arr.map(_,split(" ")).flatten

原先只是对arr中两个元素根据空格进行切分，会生成两个array，flatten就是将两个array取消掉，使arr里面仅包含切分后的元素。
arr.map(,split(" "))的结果:Array[Array(hello,world),Array(word,count)]
arr.map(,split(" ")).flatten的结果:Array(hello,world,word,count)

4. flatMap：先map在flatten
   arr.flatMap(,split(" "))的结果相当于arr.map(,split(" ")).flatten

5. foreach（循环遍历）:

arr.flatMap(_,split(" ")).foreach(x => println(x)) //打印出数组中所有元素

13、集合：集合分为可变(mutable)和不可变(immutable)两种类型。不可变集合初始化后就不再改变，内容以及长度都不可变。（定长数组:Array，变长数组:ArrayBuffer）
14、seq序列：

1. Nil表示空列表(List())
2. 列表要么为空(Nil)要么是一个head元素加上一个tail元素(除了head，其他元素都是tail里的)。
3. ::操作符是将给定的head和tail创建一个新的列表,::是一个右优先操作符。
4. list.++ -->两个集合相加返回一个新的集合
5. list.++: -->两个集合相加返回一个新的集合，右边的集合为头部
6. list +: /list :+ --> :在+右边表示在list头部添加,反之则在尾部添加
7. llist :: list1 --> list(List(list),list1)
8. list ::: list1 --> list(list,list1)
9. list.count(x => x>2) -->集合中元素大于2的个数
10. list.filter(x => x >=3) -->过滤集合中符合条件表达式的值作为集合返回
11. list.sortBy(x => x) -->升序排序 (-x则为降序)
12. list.sortWith() -->排序

val lists = List(("a","b",1),("a","c",2))
lists.sortWith((x,y) => x._3 > y._3)   //降序排序

13. list.grouped -->按指定数量分组，每组有 size 数量个元素，返回一个集合
14. list.groupBy -->按条件分组
15. list.fold(初始值)(函数) -->函数(函数(初始值,list._1),list._2)…
16. list.union -->将两个集合的元素合在一起
17. list.diff(list2) -->两个集合求差集
18. list.intersect(list2) -->两个集合求交集
19. list.zip(list2) -->将两个集合对应角标的元素组合在一起
20. list.mkString(" ") -->将list元素转成字符串，以括号里的内容连接
21. list.slice(index1, index2) -->截取
22. list.par -->并行化集合

15、set集合：无序并且不重复(hashset是可变集合,set是不可变的)
16、对象：object是一个单例的对象，并且其成员变量和方法都是静态的，不能New，通过对象.属性调用。
17、class：

1、定义在类名后面的构造器叫做主构造器，一个类中主构造器只能有一个。
2、如果主构造器中赋值的成员属性没有var/val修饰，则外部不可访问该属性。
3、主构造器中定位的属性会成为成员属性
4、成员属性用var修饰，外部可以访问也可以改值。用val修饰，外部只可取值，也就是只提供getter方法。
5、辅助构造器中必须先调用主构造器。
6、类前加private/private[this]修饰，则该类仅可被一个包下的其他类可见，当前包下的子包也不可见。private[包名]表示该类在当前包以及其子包可见。

Object和Class的区别：

1、object中的方法和字段都是静态的，可以直接用对象名.方法/变量方式调用。object的构造器是在第一次使用的时候调用，没调用过便不会执行。object有class的所有特性，还可以扩展class一个或者多个特质。object构造器无参。，main方法必须在Object中调用，因为main方法是static的，而scala没有static关键字，所以在Object中调用，模拟静态.
2、

18、伴生对象(类)：同一个scala源中名称相同的class和object。在伴生对象中可以访问类的私用成员和属性，类只会被编译，不能直接被执行。class有了Object即可得到静态.
19、trait（特质）：相当于java中的interface接口，但是可以定义有实现的方法也可以定义没有实现的方法。如果特质中没有实现的方法，其子类可以不加override关键字，如果特质中方法已经实现，那子类中重写必须加上override关键字。scala中可以动态的混入n个特质。（val s = new 对象 with 特质 with 特质2 … （s可以同时调用所有混入的特质的方法））
20、abstract （抽象类）：可以有没有实现的方法，也可以有具体实现的方法。

和特质的区别：
1、第一个继承抽象类或者特质，只能使用extends，如果想继承多个特质，可以在extends后面使用with关键字。
2、with后面只能是特质。