scala01（控制流程，方法，函数）

scala介绍

1、scala的基本介绍

当前版本2.12.8.使用最多的版本2.11.8
2.10.x系统的版本

scala在数据处理上面，真的是非常简洁

2、scala开发环境的安装

windows版本的解压zip的包，然后配置环境变量即可，一定要注意，将scala的zip的压缩包解压到一个没有中文没有空格的路径下面去，然后配置SCALA_HOME的环境变量即可

scala开发工具idea的插件的安装

3、scala的REPL

交互式的环境，所见即所得
使用:help查看帮助文档

scala的基本语法

1、申明变量以及块表达式

申明变量的基本语法
val/var 变量名 [:变量类型] = 变量值
申明一个变量，变量名 name 变量类型是String 变量值是zhangsn
注意，val修饰的变量，不可变，类似于java当中final锁定了

val name:String = "zhangsan"
println(name)
//name="list"
//使用val修改的变量不可变，使用var修改的变量可变

var age:Int = 30
println(age)
age = 50
println(age)

总结：在scala当中一般建议使用val来定义变量
类型推断，如果我们不定义变量的类型，scala会帮我们自动推断

var address = 123f
println(address)

//块表达式，返回值的类型，取决于我们最后一行代码返回的值类型
val block = {
  123
  "hello world"
  //Unit类型，类似于java当中void
  println("hello world")
}

2、scala当中常用的数据类型

scala当中的String，其实就是使用了java当中String，但是scala当中的string的方法更加丰富，scala当中给String扩展了很多方法，但是没有改String的源码，使用隐式转换来丰富了很多的方法

Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float、Double类型和1个Boolean类型。

与java当中不同，scala当中并不区分基本数据类型和引用数据类型，所有的这些类型全部都是对象，可以调用相对应的方法。在scala当中，String直接引用的是java.lang.String这个java当中的类型。由于String在需要时能隐式转换为StringOps，因此不需要任何额外的转换，String就可以使用这些方法。
每一种数据类型都有对应的Rich* 类型，如RichInt、RichChar等，为基本类型提供了更多的有用操作。

scala当中常用的类型结构图

值类型与引用类型
值类型：一些数据值
引用类型：我们自己定义的一些scala的class类，一些java类等等

null是所有引用类型的子类
nothing是所有引用类型和值类型的子类

算数操作符的重载
scala当中也有 + - * / 的操作，但是 + - * / 都是方法名

val age2 :Int = 30
//注意，这个  -  号是一个方法
println(age2 - 10)
//   如果减号是一个方法名  那么我们可以通过  .方法名去调用
println(age2.- (10))

总结 scala当中调用方法
第一种 空格 直接写方法名
第二种 .方法名（方法的参数）

流程控制语句

1、if判断

val a = 20
val aResult = if(a > 10){
  10
}else{
  30
}
println(aResult)


val b = 20
val bResult = if(b > 10){
  "hello"
}else{
  30
}
println(aResult)

2、whie循环

//while循环没有任何返回值类型,关注的是执行的过程
var e  = 1
val f = while(e <= 10){
  e += 1
}
println(f)
()

//循环终止
var g = 10
val loop = new Breaks
loop.breakable{
  val h =   while(g <=20){
    g +=1
    println(g)
    if(g == 15){
      loop.break()
    }
  }
  println(h)
}

println(g+"=============")

3、for循环

println("for=========================")
for(i <- 1 to 3;j <-  1 to 5){
  println(i * j )
1
2
3
4
5
2
4
6
8
10
3
6
9
12
15
4
8
12
16
20

}


println("for=========================")
for(i <- 1 until 5; j <- 1 until 4){
  println(i * j )
}


for(i <- 1 to 3 if(i != 2)){
  println("hello world")
}
hello world
hello world



//引入变量
for(i <- 1 to 3 ; j = i-1){
  println(i * j )

}
0
2
6




val for5 = for(i <- 1 to 5) yield  i
println(for5)


for{
  i <- 1 to 5
  j = 5-i
}
  println( i* j +"myij")

scala当中调用函数与方法

scala是一个面向函数式的编程语言，同时兼容面向对象的编程的特性

import scala.math._

sqrt(100)
res10: Double = 10.0



BigInt.probablePrime(16, scala.util.Random)

"hellWorld".distinct
res1: String = helWord


"hello"(4)
res13: Char = o

"hello".apply(4)
res0: Char = o


Array(1,2,3)
res2: Array[Int] = Array(1, 2, 3)

Array.apply(1,2,3)
res3: Array[Int] = Array(1, 2, 3)


val arr1 = new Array[Int](5)
arr1(1) = 2
arr1.update(1, 4)
println(arr1.mkString(","))
0,4,0,0,0

scala当中函数与方法的定义

方法与函数的定义形式不一样。方法就是函数，函数也是对象

1、scala当中的方法的定义

方法定义的形式：
def 方法名（参数1：参数类型1，参数2：参数类型2）：返回值的类型 = {
方法体

}

需求：定义一个方法，方法名是hello,两个参数，一个参数int类型，一个参数是string，返回值int类相关

scala定义方法的标准格式为
def 方法名(参数名1: 参数类型1, 参数名2: 参数类型2) : 返回类型 = {方法体}

示例一：定义一个最标准的方法，且定义方法的返回值类型为Int类型
def hello(first:String,second:Int) :Int = {
  second
}


示例二：定义一个方法，且不定义返回值
注意：如果定义的方法没有返回值，那么方法的返回值会做自动推断。根据我们方法的最后一个返回类型来推断我们的方法返回类型

def  hello2(first:Int , second:String) ={
  //println(first)
  //20
}
val hello2Result = hello2(20,"abc")
println( hello2Result)

示例三：定义一个方法，不定义返回值，可以通过自动推断，返回不同类型的值

def hello3(first:Int,second:String) ={
  if(first > 10){
    first
  }else{
    second
  }
}
val hello3Result = hello3(5,"helloworld")
println(hello3Result)

示例四：定义一个方法，参数给定默认值，如果不传入参数，就使用默认值来代替
def hello4(first:Int = 10,second:String)={
  println(first+"\t"+ second)
}
//注意我们在调用方法的时候我们可以通过参数名来指定我们的参数的值
hello4(second="helloworld")


示例五：变长参数，方法的参数个数不定的，类似于java当中的方法的...可变参数
def hello5(first:Int*)={
  var result = 0;
  for(arg <- first){
    result  += arg
  }
  println(result)
}
hello5(10,20,30)
hello5(10,50)

示例六：递归函数。我们可以定义一个方法，使得方法自己调用自己，形成一个递归函数，但是方法的返回值类型必须显示的手动指定
def  hello6(first:Int):Int={
  if(first <= 1){
    1
  }else{
    first * hello6(first -1)
  }
}

val hello6Result = hello6(10)
println(hello6Result)

示例七：定义一个方法，没有显示的指定返回值，那么我们方法当中定义的等号可以省掉
注意：如果省掉了=号，那么这个方法强调的就是一个代码执行的过程
/**
  * 定义了一个方法，但是方法的返回值没有显示指定，
  * 此时我们就可以省掉方法定义的=号，如果省掉 = 号，
  * 那么这个方法强调的是一个过程，代码执行的过程，
  * 不会产生任何的返回值
  * @param first
  */
def hello7(first:Int){
  println(first)
  30
}
hello7(20)

示例八：直接通过def定义一个方法
def hello8=10;
val hello8Result = hello8
println(hello8Result)


示例九：如果方法体当中只有一行代码，我们也可以省掉大括号
def hello10(first:Int,second:Int) = first+second
val hello10Result = hello10(10,20)
println(hello10Result)
定义方法使用的关键字   def

2、定义函数

关键字 =>

简单的认为，看到def就是方法，看到 => 就是一个函数

函数定义的两种形式
第一种形式：
val 函数名 = (参数名1：参数类型1，参数名2：参数类型2) => {函数体}

第二种形式：
val 函数名 ：（参数类型1，参数类型2） => (返回类型) = {
函数体
}

示例一：定义一个标准函数，使用 =>来进行定义

val func1 =(x:Int,y:Int) =>{
  x+y
}
func1(2,8)

示例二：定义匿名函数。也就是我们可以定义一个没有名字的函数
定义一个匿名函数之后，这个函数就没法使用了

(x:Int,y:String) =>{x + y}

示例三：函数定义的另外一种形式，定义一个函数，参数只有一个且是Int类型，返回值也是Int类型

val func3 :Int => Int = {x => x * x }
val func3Result = func3(10)

示例四：定义一个函数，参数值是两个，分别是Int和String，返回值是一个元组，分别是String和Int

val func4:(Int,String) =>(String,Int) ={
  (x,y) => (y,x)
}
val func4Result = func4(10,"hello")
println(func4Result)

3、方法与函数的区别，以及方法转换为函数

方法就是函数，函数也是对象
函数可以作为一个参数，传入到方法里面去