scala学习总结02

1、值类型之间的转换：
Byte short Long Int Float…
自动转换（提升）：
byte->short->int->long->float->double
char->int
scala中照样是适用
强制转换：
java：（int）1L
scala: toInt toDouble

如何转字符串: 123+"" tostring

        object type2 {
  def main(args: Array[String]): Unit = {
    //    val a=1
    val s ="123"
    val i:Int = Integer.parseInt(s)
    println(i)
    println(s.toInt)
    println(s.toDouble)
    println(123.toString)
  }
}

2、运算符：在Scala中没有真正运算符，所谓的运算符实际上是方法（函数）名。
±*/ 都是方法名
1、在Scala中调用方法的.可以省掉
2、在给方法传递参数的时候，如果这个方法的参数只有一个参数或者没有参数，则原括号可以省略。
.和（）都省略后，这个时候的方法名我们就称为运算符

 alt+enter 万能键    2、双击shift 打开查找
  赋值运算符
  比较运算符
  java： ==基本类型比较的就是值   引用类型：比的也是值：对象的地址值
             equals:只能用户引用类型  比较的内容
  Scala：==:等价于equals
              equals: 等价于==
              eq:等价于java==  只能用于AnyRef

在Scala中任何语句（执行的语句，表达式等）都有值！！是执行的最后一行代码的值自动返回。

  object operator1 {
  def main(args: Array[String]): Unit = {
//    val r:Int=1.+(2)
//    println(r)

//    var i:Int=1
//    i +=1
//    println(i)
    var a="a"
    var ab1 = a+"b"
    var ab2=a+"b"
    println(ab1 == ab2)
    println(ab1.eq(ab2))
  }
}

3、流程控制：
1、顺序流程
2、分支
java: if分支 : if 、if…else if 、if…else if else…
switch分支: switch(表达式）{case 常量; break default:break}
缺点：1、类型有限:byte、short、char、string、enum
2、case穿透 忘记break，会出现。
Scala if和java用法完全一致 无switch
模式匹配：替换掉java的switch，语法有点像，但是远远超过JAVA的switch。

object ifDemo {
  def main(args: Array[String]): Unit = {
//    val a = 10
//    if (a % 2 == 0) println(s"$a 是偶数")
//    val m =10
//    val n=20
//    var max = if (m>n) m else n
//    println(max)
    val m = 99.9
    val s = if(m < 0 ) {
      throw new IllegalArgumentException("你的参数不对")
    }else {
      math.sqrt(m)
    }

   3、循环
       java：while、 do...while....  、for   
       scala : while、do...while....  、for （遍历集合中的每个元素）和java完全一样。
       Scala是一种函数式语言，不应该有循环。

任何语句结构都有值：
1、while结构的值是Unit
2、赋值语句的值也是Unit

object whileDemo1 {
  def main(args: Array[String]): Unit = {
    var i = 0
    val r = while (i<10) {
      println(i)
      i+=1
      i
    }
    println(r)

  }

4、for循环：本质就是一种遍历，遍历集合（容器）中的每个元素，当遍历完最后一个元素之后，自动终止。

object for1 {
  def main(args: Array[String]): Unit = {
//    val a ="abc"
//    for (c <- a){  //遍历容器，c只读，不能改
//      println(c + 0)
//    }
    //使用for 输出1-100
//    for(i <-1 to 100){
//      println(i)
//    }
    //使用for输出1-100的所有奇数
//    for(i<-1 to 100 by 2){
//      println(i)
//    }
    //使用for输出100-1
//    for(i <- 1 to 100 reverse){
//      println(i)
//    }
    for(i<-100 to 1 by -1){
            println(i)
          }
  }
}

5、退出循环：Break.breakable()抓 break抛

import scala.io.StdIn
import scala.util.control.Breaks

object for03 {
  def main(args: Array[String]): Unit = {
    val n = StdIn.readInt()
    var isPrime = true
    Breaks.breakable {
      for(i<-2 until n){
      if(n%i==0) {
        isPrime =false
        Breaks.break
      }
    }
    }

6、嵌套循环：做个99乘法表

object for04 {
  def main(args: Array[String]): Unit = {
    //99乘法表
//    for(i<-1 to 9){
//      for(j<-1 to i){
//        println(s"$j*$i=${i*j}\t")
//      }
//      println()
//    }
    //所有代码都在内循环，则可以使用循环的嵌套
    //实际情况使用很少
    for (i<-1 to 9;j<-1 to i){
      print(s"$j*$i=${i*j}\t")
      if(i==j)println()
    }
  }

7、for推导

object for05 {
  def main(args: Array[String]): Unit = {
    //循环没有返回值(unit)  for推导式
    //得到一个序列：1、4、9、16......100*100
    //yield得到结果
//    val r = for(i<- 1 to 100)  yield
//      i*i
//      println(r)
    val s = for(c<-"abcd") yield c.toString.toUpperCase +c
    println(s.mkString(""))
    //更加函数式
    println("abcd".map(c=>c.toString.toUpperCase + c).mkString(""))
    }
}

8、函数的默认值：声明函数的时候。参数可以带默认值

object fun4 {
  def main(args: Array[String]): Unit = {
//    println(add(1, 2, 3))
//    println(add(10, 20, 1))
//    println(add(100, 20, 3))
//    println(add(100, 20))
    println(add(c = 100, a = 10, b = 20))
  }
  def add(a:Int,b:Int,c:Int) = a+ b +c

}

9、高级函数的定义：
1 函数可以定义在任何位置。可以在函数内定义函数
2 可以把函数当成一个值返回给函数的调用者，函数的调用者就可以在函数的外部去调用这个返回的函数
3 可以把函数当做一个值，传递给另外一个函数
4 如果一个函数可以返回一个函数作为返回值，或者可以接受一个（多个）函数作为参数，那么这个函数f称为高阶函数
5 函数和方法有哪些微妙的区别：
a、函数可以作为值传递，方法不行。
b、函数也可以直接定义。定义函数： （）=>{} 定义方法：def foo(a:Int)=printIn(a)
c、函数不能声明返回类型，只能靠推导
6 函数和方法之间有个桥梁：可通过_把方法转化成函数。如果有环境，则scala自动转换。

package com.atguigu.scala1015.day01.fun.high

object high3 {
  def main(args: Array[String]): Unit = {
//    val add1= add _
//    val add2= add _
//    println(add1(10, 20))
    val r:Int = foo(add)
    println(r)

  }
  def foo(op:(Int,Int)=>Int)={
    op(10,20)
  }
  def add(a:Int,b:Int) = a + b

}

10、匿名函数：没有名字的函数。用处：作为实参，直接传递给高阶函数。直接作为高阶函数的返回值。
2、传递：foo((a:Int,b:Int)=>(a + b))
3、在传递匿名函数的时候，参数的类型一般可以利用上下文，让scala去自动推导

object high4 {
  def main(args: Array[String]): Unit = {
    //val a = () =>println("aaaa")
//    foo(()=>{println("匿名函数")})
//    foo((a:Int,b:Int)=>(a + b))
    foo(_ + _)  //高阶函数的使用
    }

  def foo(add:(Int,Int)=>Int)={
    println(add(10, 20))
    println(add(1000, 2000))
    println(add(100, 200))
  }
}

11、手写foreach遍历集合中的每个元素，具体遍历到每个元素的时候，做什么事情，那是有调用者来确定
自动格式化：alt+ctrl+l
复制一行代码：Ctrl+d

filter过滤。过滤条件可以通过一个返回boolean的函数来实现

map:映射，一进一出

reduce：聚合操作

object high5 {
  def main(args: Array[String]): Unit = {
    val arr1 = Array(30, 5, 7, 60, 1, 20)
//    val result:Int = reduce(arr1,(x,y)=> {
//      println(s"x=$x,y=$y")
//        x+y})
    var result= reduce(arr1,_ * _)
    println(result)
//    foreach(arr1, a => {
//      println(a)
//    })
//    foreach(arr1,println)
//    val arr2=filter(arr1,_ >25)
//    foreach(arr2,println)
//    val arr2=map(arr1,x=>x*x)
//    foreach(arr2,println)


  }

  def reduce(arr:Array[Int],op:(Int,Int)=>Int):Int ={
    var sum = 1
    for(e<-arr){
      sum=op(sum,e)
    }
    sum
  }

18、闭包：一个函数和与其相关的引用环境（变量）组成的整体
闭包会阻止外部局部变量的销毁，可以把局部变量的使用延伸到函数的外部

object closure {
  def main(args: Array[String]): Unit = {
//    val f:Int => Int=foo()
//    val r:Int = f(10)
//    println(r)
    val f=foo()
    println(f())
    println(f())
    val f1=foo()
    println(f1())
  }

  def foo()={
    var a=10
    ()=>{a+=1;a}
  }
//  def foo()={
//    var a=10
//    (b:Int) => a+b
//  }
}