程序人生

Scala总结

一、基础知识：

1
2
3
4
5
6
7
8
9
10
11
12
13
1、常量和变量：尽量使用常量，可以避免很多问题
2、数据类型：
    Any
      AnyVal(等价于java的基本类型):Long、Int、StringOps、Unit
      AnyRef(等价于java的引用类型):Java中的所有类到Scala都是AnyRef、
                                   Scala中所有集合、定义的所有类、Null(只有一个null)
      Nothing:没有对象也没有子类，所有类的子类
3、数据类型之间的转换：
   AnyVal值类型转换：.toInt、.toLong
   AnyRef类型的转换：.isInstanceof[]、.asInstanceof[]
4、流程控制
   顺序、选择（有返回值）、循环(没有返回值)

二、函数式编程

img函数基本语法

高阶函数

  • 高阶函数可以接受函数作为参数，比如常见的有map,filter,reduce等函数，它们可以接受一个函数作为参数。
  • 高阶函数的返回值也可以是函数。
  • 高阶函数包含：作为值的函数、匿名函数、闭包、柯里化等等

1、作为值的函数

函数就像和数字、字符串一样，可以将函数传递给一个方法，如List的map方法，可以接收一个函数

1
2
val func:Int => String =  (num:Int) => "*" * num
println((1 to 10).map(func))

2、匿名函数

没有赋值给变量的函数就是匿名函数

1
2
3
(1 to 10).map(num => "*" * num)

(1 to 10).map("*" * _)

3、柯里化

将原先接受多个参数的方法转换为多个只有一个参数的参数列表的过程。

1
2
3
def add(x:Int)(y:Int) = {
   x + y
 }

相当于

1
2
3
4
  def add(x:Int) = {
    (y:Int) => x + y
  }
println(add(3)(4))

4、闭包

闭包其实就是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

1
2
3
4
val y = 10
def add(x:Int): Int ={
  x+y
}

三、面向对象

样例类和普通类的区别：

  • 样例类默认实现了序列化
  • 样例类使用的时候不需要new语法
  • 样例类可以进行模式匹配
  • 样例类实现了apply方法、toString方法、equals方法、hashCode方法、copy方法
1
case class People(name:String,age:Int)

四、集合

1、数组：定长数组（Array）、变长数据（ArrayBuffer）

2、列表：不可变列表（List）、可变列表（ListBuffer）

3、Set：

4、Map

  • 使用+=添加元素
  • 使用-=删除元素
  • 使用++=追加一个数组、列表

不可变集合：scala.collection.immutable

可变集合： scala.collection.mutable

五、隐式转换

隐式参数

普通方法或者函数中的参数可以通过 implicit 关键字声明为隐式参数，调用该方法时，

就可以传入该参数，编译器会在相应的作用域寻找符合条件的隐式值。

1）说明

（1） 同一个作用域中，相同类型的隐式值只能有一个

（2） 编译器按照隐式参数的类型去寻找对应类型的隐式值，与隐式值的名称无关。

（3） 隐式参数优先于默认参数 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
object TTT {

  implicit val str: String = "hello world!"

  def hello(implicit arg: String="good bey world!"): Unit = {
    println(arg)
  }
  def main(args: Array[String]): Unit = {
    hello()
  }
}
hello world!


隐式类

在 Scala2.10 后提供了隐式类，可以使用 implicit 声明类，隐式类的非常强大，同样可

以扩展类的功能，在集合中隐式类会发挥重要的作用。

1）隐式类说明

（1） 其所带的构造参数有且只能有一个

（2） 隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是顶

级的。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
object TTT {

  implicit class MyRichInt(arg: Int) {
    def myMax(i: Int): Int = {
      if (arg < i) i else arg
    }
    def myMin(i: Int) = {
      if (arg < i) arg else i
    }
  }

  def main(args: Array[String]): Unit = {
    println(1.myMax(3))
  }
}

上下文限定

六、模式匹配

模式匹配:
match 对应 Java 里的 switch，但是写在选择器表达式之后。即： 选择器 match {备选项}。
match 表达式通过以代码编写的先后次序尝试每个模式来完成计算，只要发现有一个匹配的case，剩下的case不会继续匹配。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }


配合样例类:
	for (person <- List(alice, bob, charlie)) {
        person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) =>
               println("Age: " + age + " year, name: " + name + "?")
         }
      }

七、泛型

协变和逆变

1
2
3
4
5
6
7
class MyList[**+T**]{ //协变 
} 

class MyList[**-T**]{ //逆变 
} 

class MyList[**T**] //不变

协变：Son 是 Father 的子类，则 MyList[Son] 也作为 MyList[Father]的“子类”。

逆变：Son 是 Father 的子类，则 MyList[Son]作为 MyList[Father]的“父类”。

不变：Son 是 Father 的子类，则 MyList[Father]与 MyList[Son]“无父子关系”。 3）实操

泛型上下限

泛型的上下限的作用是对传入的泛型进行限定。

1
2
Class PersonList[T <: Person]{} //泛型上限 
Class PersonList[T >: Person]{} //泛型下限