Scala教程

1. 基础语法

Scala语言是基于Java虚拟机运行的，所以基本的语法和Java是没有区别的。但是为了简化Java的开发以及融合其他的编程语言的优点和特性，Scala在基本的语法上做了大量的修改和优化，让程序员开发起来更简单，方便，灵活。

1.1 变量

Scala声明变量有两种方式，一个用val，一个用var。

val / var 变量名 : 变量类型 = 变量值。

val定义的值是不可变的，它不是一个常量，是不可变量，或称之为只读变量。

1.2. 常用类型

Scala语言是完全面向对象的语言，所以并不区分基本类型和引用类型，这些类型都是对象，我们称之为常用类型。

Scala常用类型中包含有7种数值类型：Byte、Char、Short、Int、Long、Float、Double及Boolean类型，还有String类型。

Byte	8位, 有符号
Char	16位, 无符号
Short	16位, 有符号
Int	32位, 有符号
Long	64位, 有符号
Double	64位, 双精度浮点数
Boolean	true 或者 false
String	其实就是由Char数组组成

2. 控制结构

scala中的循环表达式分为3类：① to  ②  Range   ③ until  【底层实际上都是scala.collection.immutable.Range】

• to ： 前闭后闭
• Range : 前闭后开， 可以使用步长，但是步长不能为0
• until : 前闭后开

    println(1 to 10) //Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    println(Range(1, 10)) //Range(1, 2, 3, 4, 5, 6, 7, 8, 9)
    println(Range(1, 10, 2)) // Range(1, 3, 5, 7, 9)
    println(1 until 10) // Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

2.1  if else表达式

//演示scala条件表达式
object IfScala extends App {
 
  val x = 0
  val resBoolean = if (x > 0) true else false //false
 
  // 0 > 0 不成立, 且代码没有 else 分支, res2 是什么呢
  val res2 = if (x > 0) 2 //()   相当于else ()
 
  // if ... else if ... else 代码较多时可以使用代码块{}
  val score = 78
  val res4 = {
    if (score > 60 && score < 70) "及格"
    else if (score >= 70 && score < 80) "良好" else "优秀"
  }
  println(res4)  //良好
}

注：

（1）Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容

    val a = 10
    val b = if (a>0) true else false
    print(b) // true

// ( ) => Unit => void

（2）如果大括号内的逻辑代码只有一行，大括号可以省略

    val a = 10
    if (a>0)
      print("a > 0")
    else
      print("a <= 0")

2.2 while表达式

Scala提供和Java一样的while和do循环，与If语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()。

    var n = 1;
    val while1 = while(n <= 10){
      n += 1
    }
    println(while1) // ()
    println(n) // 11


    var (sum, num) = (0, 100)
    while (num >= 0) {
      sum += num;
      num = num - 1; //scala不能num --   步长
    }
    println(sum)

3.3 for表达式

if 循环守卫：引入循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue

• 单层for循环

    for (i <- 1 to 10){
      println(i)
    }
    for (i <- 1 to 10 if i % 2 == 0){
      println(i)
    }
  
    var skills = Array("Hadoop", "Spark", "Storm", "Hive", "HBase", "Kafka")
    for (skill <- skills) {
      println(skill)
    }

• 双重for循环

//两种for循环等价
 
for(i <- 1 to 3 ; j <- 1 to 3 ; if i != j){
    println((10 * i + j) + " ")
  }
 
  for(i <- 1 to 3){
    for(j <- 1 to 3){
      if(i != j){
        println((10 * i + j) + " ")
      }
    }
  }

•  使用{} 替代()

注：{}和()对于for表达式来说都可以。for 推导式有一个不成文的约定：当for 推导式仅包含单一表达式时使用原括号，当其包含多个表达式时使用大括号。值得注意的是，使用原括号时，早前版本的Scala 要求表达式之间必须使用分号。

这里的写法和前面的等价

   
    for{i <- 1 to 3 ;j <- 1 to 3 ; if i != j}{
      println((10 * i + j) + " ")
    }

    for{i <- 1 to 3
        j <- 1 to 3
        if i != j
        } {
      println((10 * i + j) + " ")
    }

3.4 foreach表达式 

对集合中的元素做遍历

var skills = Array("Hadoop", "Spark", "Storm", "Hive", "HBase", "Kafka")
skills.foreach(x => println(x))

3.5 yeild 关键字

循环返回值:  将遍历过程中处理的结果返回到一个新集合中，使用yield关键字

    val for5 = for(i <- 1 to 10 if i % 2 == 0) yield i
    println(for5) // Vector(2, 4, 6, 8, 10)

4. 函数

4.1 函数的定义和使用

4.2 默认参数

 默认参数：在函数定义时，允许制定参数的默认值

object DefaultParam extends App {
 
  def printMessage(name: String = "itcats", age: Int = 18, country: String = "中国"): Unit = {
    println(s"$name $age $country")
  }
 
  printMessage()
  printMessage("zp")
  printMessage(age = 20, country = "美国")
}

4.3 命名参数

传统方式：实参和形参的顺序要一致

命名参数： 定义函数参数的名字，可以不按照顺序进行传参

object Function2 {
  def main(args: Array[String]): Unit = {
    //常规调用方式
    speed(100, 10)
    //命名参数调用方式1
    speed(distance = 100, time = 10)
    //命名参数调用方式2 (调换顺序)
    speed(time = 10, distance = 100)
  }
 
  //演示命名参数
  def speed(distance: Int, time: Int): Unit = {
    println(distance / time)
  }
}

4.4 可变参数

• 演示可变参数 在参数类型后加一个通配符* 即可
• 可变参数要放在参数列表中最后的位置

object Function3 {
 
  def main(args: Array[String]): Unit = {
    println(sum(1, 2, 3, 4))
  }
 
  //演示可变参数 在参数类型后加一个通配符* 即可
  def sum(nums: Int*): Int = {
    var res = 0;
    for (num <- nums) {
      res += num;
    }
    res
  }
 
  //可变参数要放在参数列表中最后的位置
  def sum1(initValue: Int, nums: Int*): Int = {
    var res = initValue;
    for (num <- nums) {
      res += num;
    }
    res
  }
  
}

5. Scala面向对象

5.1 类的定义和使用

•  占位符_ 的使用只能用var，不能用val
• var 修饰的属性会自动生成getter / setter方法
• val 修饰的属性只会生成gettter 方法
• private [this] 修饰的属性只能在本类中使用

package com.sanqian.scala.lesson3

object Test1 {
  def main(args: Array[String]): Unit = {
    //创建Person对象
    val person = new Person()
    println(person.name + " " + person.age) //null 18
    person.name = "小明"
    //person.age = 19 报错  val age 不可变
    println(person.name + " " + person.age) //小明 18
    println(person.eat)  //调用person的eat()方法   小明is eating
    person.watchMovie("泰坦尼克号")  //小明 is watching 泰坦尼克号
    person.printInfo  //调用person中的printInfo()方法    小明的性别是 male
    // person.gender 报错  private [this] 所修饰的变量只能在其本类访问,故编译不通过
  }
}
 
//在scala中定义一个类
class Person{
  //相当于书写了getter/setter(var)
  var name : String = _   //占位符_   必须为var,不能为val,否则报错 String占位符默认为null
  //相当于书写了setter(val)
  val age : Int = 18   //也可以写成 val age = 18
 
  private [this] val gender = "male"
 
  def printInfo: Unit ={
    println(name + "的性别是 "+ gender)  //private [this] 可以在本类Person中使用
  }
 
  //定义方法
  def eat():String = {
    name + "is eating"
  }
 
  def watchMovie(movieName : String) :Unit = {
    println(name + " is watching " + movieName)
  }
 
}

5.2 主构造器和附属构造器

• 主构造器：紧跟在类后面的参数列表  val或var不可省略,否则第行student.属性(省略var或val的报错,无法访问)
• 如果成员属性var修饰相当于对外提供getter/setter方法  val修饰相当于对外提供getter方法

package com.sanqian.scala.lesson3

//scala构造器演示
object Constructor {
  def main(args: Array[String]): Unit = {
    val student = new Student("小明", 20)
    println("姓名:" + student.name + " 年龄:" + student.age + " 职业:" + student.occupation) //姓名:小明 年龄:20 职业:学生

    val student2 = new Student("张三", 21, "男")
    println("姓名:" + student2.name + " 年龄:" + student2.age + " 职业:" + student2.occupation) //姓名:小明 年龄:20 职业:学生
  }
}

//主构造器：紧跟在类后面的参数列表  val或var不可省略,否则第行student.属性(省略var或val的报错,无法访问)
//如果成员属性var修饰相当于对外提供getter/setter方法  val修饰相当于对外提供getter方法
class Student(val name: String, val age: Int) {
  println("主构造器执行")
  val occupation: String = "学生"
  var gender: String = _

  //附属构造器
  def this(name: String, age: Int, gender: String) {

    this(name, age) //附属构造器第一行代码必须调用主构造器或其他附属构造器
    this.gender = gender
  }

  println("主构造器结束")
}

私有主构造器，设置主构造器的访问权限【注意private是放在主构造器前面】 

class Teacher private(var name: String, age: Int) {}

私有附属构造器

class Teacher(var name: String, age: Int) {
  var sex: String = _
 
  //私有辅助构造器
  private def this(name: String, age: Int, sex: String) = {
    //在辅助构造器中必须先调用主构造器
    this(name, age)
    this.sex = sex
  }
}

 类的成员属性访问权限：如果类的主构造器中成员属性是private修饰的，它的getter/setter方法都是私有的

class Teacher(private  var name: String, age: Int) {
    //...
}

修饰类的访问权限，私有类private [this] class XXX 

//类的前面加上private 标识这个类在当前包下都见，而且当前包下的子包不可见 默认private[this]
private[this] class Teacher(var name: String, val age: Int){}
 
//类的前面加上private[包名] 如private[itcats]表示这个类在itcats包及其子包下都可见
private[itcats] class Teacher(var name: String, val age: Int){}

5.3 继承

• 在创建子类对象的时候，首先会执行父类的构造方法
• 从父类继承过来的属性，在子类主构造器中不需要写val/var 

object ExtendApp {
  def main(args: Array[String]): Unit = {
    var an = new Bird("鹦鹉",2,"黑色")
    println(an.name + " "+an.age + " "+ an.color)
  }
}

//父类主构造器
class Animal(val name: String, val age: Int) {
  println("Animal Constructor in")
  println("Animal Constructor out")
}


//子类主构造
//这里需要注意,从父类继承过来的name,age,在子类主构造器中不需要写var/val , 而color没有继承过来,必须要写var/val
class Bird(name: String, age: Int, val color: String) extends Animal(name, age) {
  println("Bird Constructor in")

  println("Bird Constructor out")
}

5.4 重写

• 对于父类已有的属性和方法，子类重写需要加上override关键字

package com.sanqian.scala.lesson2

//重写
object OverwriteApp {
  def main(args: Array[String]): Unit = {
    var apple = new Apple("iPhone Xs",4999.9,"黑色")
    println(apple.toString)
  }
}

//父类主构造器
class Phone(var name: String, val price: Double) {
  val country = "中国"  //注意： 此处必须为val类型
}


//子类主构造
//这里需要注意,从父类继承过来的name,age,在子类主构造器中不需要写var/val , 而color没有继承过来,必须要写var/val
class Apple(name: String, price: Double, val color: String) extends Phone(name, price) {
  //重写父类的name属性
  override val country = "美国"   //val country = "美国"报错,必须要加override关键字，并且必须为val 类型  否则将会显示mutable变量不可改变的错误

  //重写toStirng()方法
  override def toString() : String = {
    "name = " + name +" , price = "+ price+" , "+"color = " +color+" , "+"country = " + country
  }
}

 5.5 抽象类

1. 抽象类使用abstract关键字修饰，且抽象类中[属性、方法]可以有具体的实现，也可以没有具体的实现
2. 抽象类没有被实例化不能使用new创建对象

package com.sanqian.scala.lesson4

object AbstractApp {
  def main(args: Array[String]): Unit = {
//    new Person() // 抽样类没有被实例化，不能创建对象
    val student = new Student3()
    println(student.name)
    student.speak
  }
}

/**
 * 类的一个或多个属性、方法没有完整的实现(只有定义，没有实现)
 */
abstract class Person {
  def speak
  val name: String
  val age: Int
}

class Student3 extends Person{
  override def speak: Unit = {
    print("speak...")
  }

  override val name: String = "zhangsan"
  override val age: Int = 22
}

 5.6 伴生类和伴生对象

1.  如果有一个class，还有一个与class同名的object，那么就称这个object时class的伴生对象，class是object的伴生类
2. 在 Scala 中，是没有 static 这个东西的，但是它也为我们提供了单例模式的实现方法，那就是使用关键字 object。object中定义的成员变量和方法都是静态的
3. Scala 中使用单例模式时，除了定义的类之外，还要定义一个同名的 object 对象，它和类的区别是，object对象不能带参数。
4. 类和它的伴生对象可以互相访问其私有成员方法和属性
5. 伴生对象可以访问类中的私有方法private，不能访问private[this]修饰的成员变量即方法

package com.sanqian.scala.lesson4

object ApplyApp {
  def main(args: Array[String]): Unit = {
//    for(i <- 1 to 10){
//      ApplyTest.incr
//    }
//    print(ApplyTest.count) // 10, 说明object 本身就是一个单例对象

    val b = ApplyTest() // ==> Object.apply

    val c = ApplyTest() // ==》Object.apply
    c() // Class.apply
    // 面试重点,结论:
    // 类名() ==> Object.apply
    // 对象() ==> Class.apply
  }
}

//伴生类
class ApplyTest{
  def apply() = {
    println("class ApplyTest apply...")
  }
}


//伴生对象
object ApplyTest{
  println("object ApplyTest enter....")
  var count = 0

  def incr = {
    count += 1
  }
  // 最佳实践: 在Object的中apply方法中去new Class
  def apply(): ApplyTest = {
    println("Object ApplyTest apply...")
    new ApplyTest()
  }
  println("object ApplyTest leave....")
}

输出：

object ApplyTest enter....
object ApplyTest leave....
Object ApplyTest apply...
Object ApplyTest apply...
class ApplyTest apply...

面试重点,结论:
    // 类名() ==> 调用Object.apply
    // 对象() ==> 调用Class.apply

最佳实践： 在Object的中apply方法中去new Class

 5.7 case class 

1. 与普通类的区别是不用new，可以直接调用
2. 通常用在模式匹配

object CaseClassAPP {
  def main(args: Array[String]): Unit = {
    println(Dog("wangcai").name)
  }
}

case class Dog(name: String)

5.8 Trait

1. Scala Trait(特征) 作用相当于 Java 的接口，实际上它比接口还功能强大。与接口不同的是，它还可以定义属性和方法的实现。
2. 一般情况下Scala的类只能够继承单一父类，但是如果是 Trait(特征) 的话就可以继承多个，从结果来看就是实现了多重继承。
3. 如果特质中trait某个方法有具体的实现，在子类继承重写的时候必须使用override关键字。如果特质方法没有具体的实现，子类在实现的时候可以不加override关键字也可以加

 一个类可以继承多个特质使用with进行连接

总结：

1、类与对象都可以混入一个或多个特质

2、特质中可以定义有具体实现的方法和没有具体实现的方法

3、如果一个类或者一个对象(继承)混入了某一个特质，这个特质中有一个未被实现的方法A和一个已实现的方法B

这个类或对象必须实现这个没有实现的方法A，且可选择性的重写方法B，必须使用override关键字。

提问：Scala中特质trait与抽象类abstract的区别？

优先使用特质trait。一个类扩展多个特质trait是很方便的，但却只能扩展一个抽象类。
如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行。例如：
trait t(i: Int) {}，参数i是非法的。

 6. Scala集合

1. Scala同时支持可变集合(比如Java中的ArrayList ， 长度可以动态改变)和不可变集合(比如Java中的数组，一旦初始化长度不可改变)，不可变集合从不可变，可以安全的并发访问。

2. 两个主要的包：

不可变集合：scala.collection.immutable (默认使用)

可变集合：  scala.collection.mutable

3. Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本。

4. Scala 的集合有三大类:序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable 特质 在 Scala 中集合有可变(mutable)和不可变(immutable)两种类型，immutable 类型的集合 初始化后就不能改变了(注意与 val 修饰的变量进行区别)

• 5. 不可变集合的继承层次

1. 

•  6. 可变集合的继承层次 : 略

6.1 定长数据Array

•  使用new 的方式创建数据不够优雅，可以使用下面这种

• 其他操作： 求和、最大值、最小值、打印

 6.2 可变数组ArrayBuffer 

• 可变数组：长度可变、内容可变

• 可变数组与不可变数组的转换

arr1.toBuffer
arr2.toArray

• 遍历数组 

两种方式

• 反转打印数组

 6.3 定长List

1. Nil就是一个空的list
2. l.head ： 获取第一个元素
3. l.tail : 获取除第一个元素之外其他元素
4. 使用:: 合并List（）数组

 6.3 可变List

• 增加元素

• 减少元素 

 

•  可变List转定长List

 

• 实现一个求和（ ：_* 可把Seq转换成可变参数）

 

 6.4 Set

1. set 是一个无序的不重复的集合
2. 可变Set   collection.mutable.HashSet

scala> val hset = collection.mutable.HashSet(1,3,4)
hset: scala.collection.mutable.HashSet[Int] = Set(1, 3, 4)
 
scala> val set = Set(1,2,3,3)
set: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
 
scala> hset.add(5)
res26: Boolean = true
 
scala> hset
res27: scala.collection.mutable.HashSet[Int] = Set(1, 5, 3, 4)
 
scala> hset.add(1)
res28: Boolean = false
 
scala> hset.remove(1)
res29: Boolean = true
 
scala> hset.remove(999)
res30: Boolean = false
 
scala> hset.-=(3)
res31: hset.type = Set(5, 4)
 
scala> hset ++ Set(0,9)  //++ 原集合数值无变化
res33: scala.collection.mutable.HashSet[Int] = Set(0, 9, 5, 4)
 
scala> hset ++= Set(0,9)  //++=原集合数据发生变化
res34: hset.type = Set(0, 9, 5, 4)

7. 模式匹配

7.1 最基础的模式匹配

object BaseMatch {
  val a: Array[String] = Array("a,", "b", "c", "d")
  val name: String = a(Random.nextInt(a.length))
  name match {
    case "a" => println("This is a")
    case "b" => println("This is b")
    case "c" => println("This is c")
    case "d" => println("This is d")
    case _   => println("Can not find it")
  }
 
  def matchMethod(num : Int) :String = num match {
    case 1 => "This is a"
    case 2 => "This is b"
    case 3 => "This is c"
    case 4 => "This is d"
    case 4 => "This is e"
    case _ => "Can not fiSnd it"
  }
 
  def main(str: Array[String]): Unit = {
     //一旦匹配上就直接退出模式匹配
     matchMethod(4)  //返回是"This is d"
  }
}

7.2 加条件进行匹配

object BaseMatch extends App {
  print(matchMethod("haha",4))   //This is d
  def matchMethod(keyword: String, num: Int): String = num match {
    case 1 => "This is a"
    case 2 => "This is b"
    case 3 => "This is c"
    case 4 if (keyword == "haha") => "This is d" // 双重过滤
    case _ => "Can not fiSnd it"
  }
}

7.3 Array模式匹配
 

def who(arr : Array[String]): Unit = arr match {
    //只匹配数组中含有一个"zhangsan"的case
    case Array("zhangsan") => println("This is zhangsan")
    case Array("zhangsan","lisi") => println("This is zhangsan and lisi")
    //匹配数组中只含三个元素的case(对元素没有要求)
    case Array(x,y,z) => println("This is x,y,z")
    //匹配第一个为wangwu,后可有可无任意多个元素的case
    case Array("wangwu",_*) => println("This is wangwu and others")
    case _ => println("who is it?")
  }

7.4 List模式匹配

与Array的模式匹配十分相似

def whoList(list : List[String]): Unit = list match {
    //只匹配数组中含有一个"zhangsan"的case
    case "zhangsan"::Nil => println("This is zhangsan")
    case "zhangsan"::"lisi"::Nil => println("This is zhangsan and lisi")
    //匹配数组中只含三个元素的case(对元素没有要求)
    case x::y::z::Nil => println("This is x,y,z")
    //匹配第一个为wangwu,后可有可无任意多个元素的case
    case "wangwu"::tail => println("This is wangwu and others")
    case m :: n => println("匹配拥有head,tail的List集合")
    case _ => println("who is it?")
  }

7.5 类型匹配

 //类型模式匹配
  matchType(Map("haha" -> "hehe"))
  def matchType(obj : Any): Unit = {
    obj match{
      case x:Int => println("Int")
      case y:String => println("String")
      case z:Map[_,_] => z.foreach(println)
      case _ => println("unkown")
    }
  }

7.6 Scala异常处理

//Scala中的异常处理
object MyException extends App {
  try{
    val i = 1 / 0; //制造异常
  }catch {
    case e:ArithmeticException => println("除数不能为0")
    case e:Exception => println("出现了未知异常")
  }finally {
    println("关闭资源处理")
  }
}

7.7 case class 模式匹配

object CaseClassMatch extends App {
 
  def caseMatch(plane : Plane): Unit = plane match {
    case Boeing(name: String, age: Int) => println("This is boeing 787 , age is 2")
    case Airbus(name: String, age: Double) => println("This is airbus 330 , age is 0.8")
    case Other(name: String, age: Int) => println("This is 战斗机 , age is 7")
  }
 
  caseMatch(Boeing("播音787",2))
  caseMatch(Airbus("空客330",0.8))
  caseMatch(Other("战斗机",7))
}
 
class Plane
 
case class Boeing(name: String, age: Int) extends Plane {}
 
case class Airbus(name: String, age: Double) extends Plane {}
 
case class Other(name: String, age: Int) extends Plane {}

8. Scala高级函数
 

8.1 字符串高级操作

1. 字符串的插值：'s'允许在处理字符串时直接使用变量，可以加{} 也可以不加{}
2. 多行字符串的表示： 使用三引号""" """ （与python用法相同）

object StringApi extends App {
  val name = "itcats_cn"
  val job = "student"
  val age = 999.999d
 
  //普通输出 加了, 会自动产生一个()
  println("name=" + name, "job=" + job)  //输出结果 (name=itcats_cn,job=student)
 
  // 文字'f'插值器允许创建一个格式化的字符串，类似于 C 语言中的 printf。
  // 在使用'f'插值器时，所有变量引用都应该是 printf 样式格式说明符，如%d，%i，%f 等。
  println(f"姓名: $name%s 年龄: $age%1.2f 职业: $job") // 该行输出有换行
  printf("姓名: %s 年龄: %1.2f 职业: %s", name, age, job) // 该行输出没有换行
 
  // 's'允许在处理字符串时直接使用变量。
  // 在println语句中将String变量($name)附加到普通字符串中。
  println()
  println(s"姓名: ${name} 年龄: $age 职业: $job")   //可以{}也可以不{}
 
  // 字符串插入器还可以处理任意表达式。
  // 使用's'字符串插入器处理具有任意表达式(${1 + 1})的字符串(1 + 1)的以下代码片段。 任何表达式都可以嵌入到${}中。
  println(s"1 + 1 = ${1 + 1}")  // 1 + 1 = 2
 
  //多行字符串演示(连续输入三个"后按回车)
  val c =
    """
      |Hello
      |World
    """.stripMargin
  println(c)
}

8.2 匿名函数

匿名函数： 函数是可以命名的，也可以不命名
语法： (参数名: 参数类型...) => 函数体

//匿名函数:函数是可以命名也可以匿名的
object AnonymityApp extends App {
  //命名函数定义
  def hello(name: String): Unit = {
    println(s"Hello : $name")
  }
 
  //匿名函数可以传递给变量
  val f = (name:String) => println(s"Hello : $name")
  //也可以传递给函数
  def an = (name:String) => println(s"Hello : $name")
 
  //调用
  hello("a")
  f("b")
  an("c")
}

8.3 currying函数(柯里化函数)

 柯里化： 将接收一个参数的函数，转换成2个

object CurryApp extends App {
  //curry函数:将原来接收两个参数的一个函数,转换成2个
  //原函数写法
  def sum(a: Double, b: Double): Double = {
    a + b
  }
 
  //curry函数
  def currySum(a: Double)(b: Double): Double = {
    a + b
  }
 
  //柯里化的演变过程
  def add(x: Int) = (y: Int) => x + y //(y: Int) => x + y 为一个匿名函数, 
  //也就意味着 add 方法的返回值为一个匿名函数
  //高阶函数,方法的参数是函数或方法的返回值是函数的函数
 
  //调用
  println(   sum(1,1)         )
  println(   currySum(1)(1)   )
}

8.4 高阶函数

map ：逐个去操作集合中的每个元素

object HighLevelFunction extends App {
  val l = List(1, 2, 3, 4, 5)
 
  //1.map 逐个操作集合里面的每个元素 实际上是建立一种映射关系,返回的是一个新的数组
  l.map((x: Int) => x + 1) //将List内的每个元素(x:Int) + 1
  l.map(x => x + 1)        //scala能帮我们推断出List内每个元素是Int,且只有一个元素时候,括号可以省略
  l.map(_ + 1)             //对List中的任意元素都 + 1
  //遍历
  l.map(_ + 1).foreach(print)    //23456 List[Int]
 
  println()
  println("-------------")
 
  //2.在map取出每个元素 + 1的基础上,使用filter过滤出 < 4的数字
  l.map(_ + 1).filter(_ < 4).foreach(print)   //23  List[Int]
 
  println()
  println("-------------")
 
  //3.使用take取集合中的前3个元素
  l.take(3).foreach(print)      //123    List[Int]
 
  println()
  println("-------------")
 
  //4.reduce
  print(  l.reduce(_ + _)  )  //15     Int  将l集合中的前后元素两两相加 1+2 3+3 6+4 10+5
 
  println()
  println("-------------")
 
  //5.reduceLeft = reduce
  print(  l.reduceLeft(_ - _)  )   //-13  1 - 2 - 3 - 4 - 5 = -13
 
  println()
  println("-------------")
 
  //6.reduceRight
  print(  l.reduceRight(_ - _)  )  //3   （ 1 - ( 2 - ( 3 - ( 4 - 5 ））））
 
  println()
  println("-------------")
 
  //7.fold(第一个括号代表初始值)
  print(  l.fold(0)(_ - _)  )    //-15  0-1-2-3-4-5 = -15
 
  println()
  println("-------------")
 
  //8.foldLeft = fold  (0在最左边)
  print(  l.foldLeft(0)(_ - _))  //-15  0-1-2-3-4-5 = -15
 
  println()
  println("-------------")
 
  //9.foldRight        (0在最右边)
  print(  l.foldRight(0)(_ - _) ) //3    ( 1 - ( 2 - ( 3 - ( 4 - (5 - 0) ) ) ) )
 
  println()
  println("-------------")
 
  //10.flatten
  val f = List(List(1,2),List(3,4),List(5,6)) //List内部是一个List类型的元祖
  print(f.flatten)   //flatten可以理解为压扁  List(1, 2, 3, 4, 5, 6)
 
  //11.flatMap(可以理解为map + flatten)
  println()
  println("-------------")
  //先来看一个例子,将f中List元祖都扩大两倍(使用map) 第一次使用map取出来的是List(x,y) 第二次用map取出来的是(x,y)
  print(f.map(_.map(_ * 2)))   //List(List(2, 4), List(6, 8), List(10, 12))
 
  println()
  println("-------------")
 
  //flatMap所实现的效果是  List(2, 4, 6, 8, 10, 12)
  print(f.flatMap(_.map(_ * 2)))
 
  println()
  println("-------------")
 
  //12.flatMap的一些应用
  val t = List("hello,hello,world,hello")
  // t.flatMap(_.split(","))   List(hello, hello, world, hello)
  t.flatMap(_.split(",")).map(x => (x,1)).foreach(println)
  /**
    * 输出:
    *   (hello,1)
        (hello,1)
        (world,1)
        (hello,1)
    */
}

并行聚合 

scala> list.aggregate
   def aggregate[B](z: => B)(seqop: (B, Int) => B,combop: (B, B) => B): B
 
scala> list.aggregate(0)(_ + _ , _ + _)
res6: Int = 10

并集union 

scala> list
res7: List[Int] = List(1, 2, 3, 4)
 
scala> val list1 = List(1,6)
list1: List[Int] = List(1, 6)
 
scala> list.union(list1)
res20: List[Int] = List(1, 2, 3, 4, 1, 6)

交集intersect

scala> list.intersect(list1)
res21: List[Int] = List(1)

差集diff

scala> list.diff(list1)
res22: List[Int] = List(2, 3, 4)

角标元素合并组合成元组zip

scala> list
res23: List[Int] = List(1, 2, 3, 4)
 
scala> list1
res24: List[Int] = List(1, 6)
 
scala> list.zip(list1)
res25: List[(Int, Int)] = List((1,1), (2,6))

9. Scala隐式转换

10. Scala操作外部数据

包括文件、网络数据、MySQL、XML等外部数据

10.1 操作文件/网络资源

//使用scala操作File文件
object FileTest {
  def main(args: Array[String]): Unit = {
    //读取文件
    var file = scala.io.Source.fromFile("/Users/fatah/Desktop/1.txt")(scala.io.Codec.UTF8);
    //var file = scala.io.Source.fromFile("/Users/fatah/Desktop/1.txt");
    def readLine(): Unit = {
      for (line <- file.getLines()) {
        println(line)
      }
    }
    //调用读取文件资源
    //readLine
    //调用读取网络资源
    readNet
    
    //读取网络数据
    def readNet(): Unit ={
      var file = scala.io.Source.fromURL("https://www.baidu.com");
      for(line <- file.getLines()){
        println(line)
      }
    }
  }
}

10.2 操作XML

10.3 操作MySQL

//使用scala连接数据库,操作MySQL
object MySQLTest {
  def main(args: Array[String]): Unit = {
    //书写连接数据库相关信息
    val url = "jdbc:mysql://localhost:3306/crash_course"
    val username = "root"
    val password = "root"
 
    //在scala中这一步与Java的class.forName写法有所不同
    try {
      classOf[com.mysql.jdbc.Driver]
      val conn = DriverManager.getConnection(url,username,password)
      val sql = "select * from orders"
      val stmt = conn.prepareStatement(sql)
      val rs = stmt.executeQuery();
      while(rs.next()){
        val order_num = rs.getString("order_num")
        val order_date = rs.getString("order_date")
        val cust_id = rs.getString("cust_id")
        println(s"$order_num , $order_date , $cust_id")
      }
    }catch {
      case e : Exception => e.printStackTrace()
    }finally {
        //关闭资源,懒得关了,懂就行
    }
  }
}