Scala总结_scala静态代码块-优快云博客

本文链接：https://blog.youkuaiyun.com/xiaodi2016/article/details/122386034

1>Java是面向对象的语言. Scala是完全面向对象的语言.
2>object : 因为Scala是完全面向对象的语言，因此很多不是面向对象的东西在Scala中不存在.
            例如: static语法
            通过object修饰"类，在底层可以模拟static语法。
3>object声明的"类"编译后会生产两个字节码文件
    类名.class
    类名$.class
        1. 当前类型的静态变量
                   public static Scala02_object$ MODULE$;  //伴生对象
        2.静态代码块
              static {
                new Scala02_object$();
             }
        3. 私有构造器  (单例)
            private Scala02_object$() {
                  MODULE$ = this;
               }
        4：类名.class中：(程序的入口)
            public static void main(final String[] args) {
                  Scala02_object$.MODULE$.main(var0);
               }
        5：类名$.class中:
            public void main(final String[] args) {
                  .MODULE$.println("Hello object");
                  this.test();
               }
        6：代码执行:
           类名.class  => static方法 =>  类名$.class => 普通方法 => 语句
        
class : (class修饰的就是相当于一个java中的普通类，没有main方法入口)
1>  class修饰的类编译后只有一个字节码文件: 类名.class
2>  反编译以后发现:
        public class Scala03_class {
           public void main(final String[] args) {
              .MODULE$.println("Hello class");
           }
        }
3>  添加main方法  public void main(String[] args){} 
4>  在方法中添加语句:
        public void main(final String[] args) {
              .MODULE$.println("Hello class");
           }
5>  代码执行：    new Scala03_class().main()

标识符

Scala - 变量
1>类型推断
    编译器能够通过对象或者值推断出具体的类型，声明变量时， 类型可以省略不写.
    var name = "李四"
    var age  = 35L
2>变量初始化
    JAVA :  int i = 10 ;   声明的同时初始化
            int i ;  i = 10 ; 先声明后初始化
    SCALA :  声明的同时初始化
             var address : String  = "beijing"
3>可变变量 var     不可变变量 val

字符串

package chapter02
/*
// Scala中直接使用Java中的String类.
    // 声明别名
    // type String  = java.lang.String
 */
object Scala01_variable {
  def main(args: Array[String]): Unit = {
    var username  = "zhangsan"
    var userage  = 30
    // 字符串拼接
    //1. +
    println( "username = " + username + ", userage = " + userage)

    //2. 插值字符串
    printf("username = %s , userage = %s " ,username, userage)
    println()
    //3. 传值字符串
    println(s"username = $username , userage = $userage")
    //4. 多行字符串
    var sql = "select id , count(id) c_id from user where id > ? group by id having c_id > ? order by c_id desc "
    println(sql)
    var sql1 =
      """
        |select
        |  id, count(id)
        |from
        |  user
        |where
        |  id > ?
        |group by
        |   id
        |having
        |   c_id > ?
        |order by
        |   c_id
        |desc
      """.stripMargin

    println(sql1)

  }

}

SCALA输入IO

package chapter02

import java.io.{BufferedReader, File, FileInputStream, InputStreamReader}
import scala.io.{BufferedSource, Source, StdIn}
import scala.reflect.io.File

/*
// Scala中直接使用Java中的String类.
    // 声明别名
    // type String  = java.lang.String
 */
object Scala01_variable {
  def main(args: Array[String]): Unit = {
    /*println("请输入名字...")
    val name: String = StdIn.readLine()
    println(name)*/

    //2.文件流  java的io
    val fis = new FileInputStream(new File("word1.txt"))
    val isr: InputStreamReader = new InputStreamReader(fis)
    val br: BufferedReader = new BufferedReader(isr)
    var flag : Boolean = true
    while (flag){
      val line: String = br.readLine()
      if (line == null){
        flag = false
      }else {
        println(line)
      }
    }
    br.close()

    println("---------------------------------------")
    val lines: BufferedSource = Source.fromFile("word.txt")
    while (lines.hasNext){
      val line: Char = lines.next()
      println(line)
    }
    
    Source.fromFile("word.txt").getLines().foreach(println)
    
    
  }
}

/*
Scala中的数组:
          1. 不可变  Array
          2. 可变:   ArrayBuffer
 */
object Scala01_array {
  def main(args: Array[String]): Unit = {
    //1. 创建对象
    val array: Array[Int] = new Array[Int](5)
    val array1: Array[Int] = Array(1, 2, 3, 4, 5)
    //2. 基本操作
    array.update(0,1)
    println(array.mkString(" , "))
    //  符号操作
    // :+
    var array2: Array[Int] = array :+(6)
    println(array2.mkString(" , "))
    val array3: Array[Int] = 6 +: array
    println(array3.mkString(" , "))


  }
}

 //可变数组  ArrayBuffer
    //1. 创建对象
    val buffer: ArrayBuffer[Int] = new ArrayBuffer[Int]()
    val buffer1: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)
    //2. 操作
    buffer1.append(6,7,8)
    println(buffer1)
    buffer1.update(0,0)
    println(buffer1)

    buffer1.remove(0)
    println(buffer1)

    buffer1.remove(1,3)
    println(buffer1)

    //3.打印
    println(buffer1)

//1. 数组其他操作
    // 多维数组
    val array: Array[Array[Int]] = Array.ofDim[Int](3, 3)
    for (ele <- array){
      println(ele.mkString(" , "))
    }
    //合并数组
    val array1 = Array(1,2,3)
    val array2 = Array(4,5,6)
    val array3: Array[Int] = Array.concat(array1, array2)
    println(array3.mkString(" , "))
    //创建指定范围的数组
    val array4: Array[Int] = Array.range(1, 10, 2)
    println(array4.mkString(" , "))
    //创建并填充指定值的数组
    val array5: Array[Int] = Array.fill(5)(-1)
    println(array5.mkString(" , "))
    //2. 转换
    val array6 = Array(1,2,3,4)
    val array7: ArrayBuffer[Int] = ArrayBuffer(5,6,7,8)
    // 不可变 -> 可变
    val arrTobuu: mutable.Buffer[Int] = array6.toBuffer
    // 可变 -> 不可变
    val array8: Array[Int] = array7.toArray

/*
     Scala中的List:
            1. 不可变 List
            2. 可变  ListBuffer
     */
    //不可变
    val list: List[Int] = List(1, 2, 3, 4, 5)
    println(list.getClass.getName)  // ::
    println(list)
    val ele: Int = list(0)
    println(ele)

    val list1: Nil.type = Nil
    println(list1)
    //::
    val list2: List[Int] = 1 :: 2 :: 3 :: 4 :: 5 :: Nil
    println(list2)
    //:::    将一个整体数据拆分成个体来使用,扁平化操作
    val list3: List[Int] = 1 :: 2 :: 3 :: List(4, 5, 6) ::: Nil
    println(list3)
    // 连接集合
    val list5: List[Int] = List.concat(list3, List(100,200))
    // 创建一个指定重复数量的元素列表
    val list6: List[String] = List.fill[String](3)("a")

  }

def main(args: Array[String]): Unit = {
   //Scala - 集合 - set
    /*
     Set的特点: 无序不重复
     Scala中的Set:
          1. 不可变  Set
          2. 可变   mutable.Set
     */
    // 不可变Set
    val set: Set[Int] = Set(1, 2, 3, 3, 4, 4, 5, 5, 6, 7, 7)
    println(set)
    //可变Set
    val mset: mutable.Set[Int] = mutable.Set(1, 2, 3, 3, 4, 4, 5, 5, 6, 7, 7)
    println(mset)
    mset.add(8);println(mset)
    mset.update(9,true)// add
    println(mset)
    mset.update(10,false)// 不做操作
    println(mset)
    mset.update(1,true) //不做操作
    println(mset)
    mset.update(1,false) //remove
    println(mset)
    mset.remove(5)
    println(mset)
    mset.remove(100)
    println(mset)
  }

def main(args: Array[String]): Unit = {
  /*
  map的特点: 存储k-v键值对, 无序不重复
   Scala中的map:
         1.不可变  Map
         2.可变    mutable.Map
   */
  // 不可变
  // 键值对：  k -> v
  val map: Map[String, Int] = Map("a"->1 , "b"->2 ,"c"->3  ,"d"->4 ,"e"->5 , "a"->11 )
    println(map)
    //可变
    val mmap: mutable.Map[String, Int] = mutable.Map("a"->1 , "b"->2 ,"c"->3  ,"d"->4 ,"e"->5 , "a"->11)
    println(mmap)
    mmap.put("f",22)
    println(mmap)
    mmap.update("a",111)
    println(mmap)
    val option: Option[Int] = mmap.remove("aa")
    if (option.isEmpty){
      println("移除失败")
    }else{
      val value: Int = option.get
      println("移除的值: " + value)
    }
    //通过k查询v
    val v: Int = mmap("a")
    println(v)
    //查询不到返回-1
    val v1: Int = mmap.getOrElse("aaa",-1)
    println(v)

    //map的迭代
    val set: collection.Set[String] = mmap.keySet
    println(set + "-----------------------")
    val keys: Iterable[String] = mmap.keys
    println(keys + "========================")
    val iterator: Iterator[String] = mmap.keysIterator
    while (iterator.hasNext){
      println(iterator.next())
    }
    //value
    val values: Iterable[Int] = mmap.values
    println(values)
    val iteratorV: Iterator[Int] = mmap.valuesIterator
    while (iteratorV.hasNext){
      println(iteratorV.next())
    }
    for (ele <- mmap){
      println(ele)
    }
    println("---------------------------------")
    //map与其他集合的转换
    // k -> v  =>  (k,v)
    val array: Array[(String, Int)] = map.toArray
    println(array.mkString(" , "))
    val list: List[(String, Int)] = mmap.toList
    println(list)
    val toSet: Set[(String, Int)] = mmap.toSet
    println(toSet)
  }

//Scala - 集合 - 元组
    val tuple: (String, Int, Char, Boolean) = ("zhangsan" , 30 , 'A' , false )
    println(tuple)
    //获取元组的元素
    //1.
    val zhangsan: Any = tuple.productElement(0)
    println(zhangsan)
    //2:
    val iterator: Iterator[Any] = tuple.productIterator
    //3:
    val name: String = tuple._1
    val age: Int = tuple._2
    val char: Char = tuple._3
    val boo: Boolean = tuple._4
    println(s"$name , $age , $char , $boo")


    //Map与tuple的关系:
    //Map中的k->v 本质上就是一个两个元素的元组. 称之为对偶元组.
    val map: Map[String, Int] = Map("a" -> 1, "b" -> 2, "c" -> 3, "d" -> 4, ("e", 5))
    println(map)

    println(map.toList)
    println("----------------------------------------------")
    //元组中最多放多少个元素? 22
    val tuple1= (0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1)
    println(tuple1)

    //函数的参数最多能放多少个呢？
    //函数仅仅作为语法结构来调用的话， 参数没有限制.
    //函数作为值来使用,最多支持22个参数.

    def fun(i1:Int,i2:Int,i3:Int,i4:Int,i5:Int,i6:Int,i7:Int,i8:Int,i9:Int,i10:Int,
            i11:Int,i12:Int,i13:Int,i14:Int,i15:Int,i16:Int,i17:Int,i18:Int,i19:Int,i20:Int,
            i21:Int,i22:Int): Unit ={
      println("fun....")
    }

    fun(0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1)
    var f = fun _

WordCount案例

def main(args: Array[String]): Unit = {
    //统计单词个数  方案一
    var datas = List(
      ("Hello Scala" , 4),
      ("Hello Spark" ,2)
    )
    val words: List[String] = datas.map(
      t =>
        (t._1 + " ") * (t._2)
    )
    println(words)
    val list: List[String] = words.flatMap(_.split(" "))
    println(list)
    val stringToStrings: Map[String, List[String]] = list.groupBy(t => t)
    println(stringToStrings)
    val wordCount: Map[String, Int] = stringToStrings.mapValues(_.size)
    println(wordCount)
    println("=================================")
    val result: Map[String, Int] =
      datas.map(t => (t._1 + " ") * t._2)
        .flatMap( _.split(" "))
        .groupBy(word => word)
        .map(kv => (kv._1, kv._2.size))
    println(result)
    println("=================================")
    //方案二

    val tuples: List[(String, Int)] = datas.flatMap(
      t => t._1.split(" ").map((_, t._2))
    )
    println(tuples)
    val stringToTuples: Map[String, List[(String, Int)]] = tuples.groupBy(_._1)
    println(stringToTuples)
    val stringToInt: Map[String, Int] = stringToTuples.map(
      kv => (kv._1, kv._2.map(_._2).sum
      ))
    println(stringToInt)
  }

集合中常用的方法

val list = List(1,2,3,4,5)
    //1. 集合长度
    println(list.size)
    println(list.length)

    //2. 集合是否为空
    println(list.isEmpty)
    println(list.nonEmpty)

    //3. 集合迭代器
    val iterator: Iterator[Int] = list.iterator
    while(iterator.hasNext){
      println(iterator.next())
    }

    //4. 集合头
    println(list.head)
    println("--------------")

    //5. 集合尾
    println(list.tail)
    println("--------------")

    //6.集合最后一个元素
    println(list.last)
    println("--------------")

    //7.集合init
    println(list.init)
    println("--------------")

    //8. 集合tail迭代
    val tails: Iterator[List[Int]] = list.tails
    while(tails.hasNext){
      println(tails.next())
    }
    println("--------------")

    //9.集合init迭代
    val inits: Iterator[List[Int]] = list.inits
    while(inits.hasNext){
      println(inits.next())
    }
    println("--------------")

    //10. 集合循环遍历  foreach

    def myprintln(ele:Int) :Unit = {
      println(ele)
    }
    //list.foreach(myprintln)
    //list.foreach( (ele:Int) => {println(ele)} )
    //list.foreach( ele => println(ele) )
    //特殊情况
    //list.foreach(  println(_) )  // _的嵌套
    list.foreach(  println )  // _的嵌套

    //_.touppercase
    println("--------------")

    //11. 将集合转换为字符串
    println(list.mkString(" , "))
    println("--------------")
    //12. 判断集合中是否包含某个元素
    println(list.contains(1))
    println("--------------")
    //13. 取集合的前几个元素
    println(list.take(2))
    println("--------------")
    //14. 取集合的后几个元素
    println(list.takeRight(2))
    println("--------------")

    //15. 丢弃前几个元素
    println(list.drop(2))
    println("--------------")
    //16. 丢弃后几个元素
    println(list.dropRight(2))
    println("--------------")
    //17.反转集合
    println(list.reverse)
    println("--------------")
    //18.去重
    val list1 = List(1,1,2,3,3,4,5,5)
    println(list1.distinct)
    println("--------------")
    //19.查找集合中的元素,返回满足条件的第一个元素
    //找偶数
    //println(list.find( (ele: Int) => {ele % 2 == 0} ))
    println(list.find( _ % 2 == 0 ))
    println("--------------")

    val list2 = List(1,2,3,4,5)
    val list3 = List(3,4,5,6,7,8)
    //20.集合并集
    println(list2.union(list3))
    println("--------------")
    //21.集合交集
    println(list2.intersect(list3))
    println("--------------")
    //22.集合差集
    println(list2.diff(list3))
    println(list3.diff(list2))
    println("--------------")
    //23.切分集合
    println(list.splitAt(3))
    println("--------------")
    //24.滑动
    list.sliding(3).foreach(println)
    println("--------------")
    //25.滚动
    list.sliding(3,2).foreach(println)
    println("--------------")
    //26.拉链
    println(list2.zip(list3))
    println("--------------")

    //27.索引拉链
    println(list.zipWithIndex)
    println("--------------")

    val list4 = List("a","b","c")

    //28.最小值
    println(list.min)
    println(list4.min)
    println("--------------")
    //29.最大值
    println(list4.max)
    println(list.max)
    println("--------------")
    //30.求和
    //println(list4.sum)
    println(list.sum)
    println("--------------")
    //31.乘积
    //println(list4.product)
    println(list.product)
    println("--------------")
    val list = List(1,2,3,4,5)
    //32. 集合规约
    // Map(映射 分)Reduce(规约 合)
    val i: Int = list.reduce(_ + _)
    println(i)
    //33. 左规约
    println(list.reduceLeft(_ + _))
    //34. 右规约
    println(list.reduceRight(_ + _))
    val list1 = List(1,2,3,4,5)
    println( list1.reduce( _ - _))     // -8   -13
    println( list1.reduceLeft(_ - _))  // -8   -13
    println( list1.reduceRight(_ - _)) // -2    3
    println("--------------------------")
    //35. fold  规约的时候先给一个初始值
    println(list.fold(6)(_ + _))
    //36. foldLeft
    println(list.foldLeft(6)(_ + _))
    //37. foldRight
    println(list.foldRight(6)(_ + _))
    println("--------------------------")
    println(list.fold(6)(_ - _))   //  -9
    println(list.foldLeft(6)(_ - _)) // -9
    println(list.foldRight(6)(_ - _)) // -3
    //38. scan
    println(list.scan(6)(_ + _))
    //39. scanLeft
    println(list.scanLeft(6)(_ + _))
    //40. scanRight
    println(list.scanRight(6)(_ + _))
    //41. map : 映射, 将集合按照在指定的规则转换成新的集合.
    //需求: 将如下集合中的每个元素加1
    val list = List(1,2,3,4,5)
    println(list.map(_ + 1))
    //需求: 将如下集合中的每个元素的首字母提取并转大写
    val list1 = List("hello","world","scala","zookeeper")
    println(list1.map(_.substring(0, 1).toUpperCase))
    //42.flatten : 集合扁平化 , 将集合中的元素(集合)拆分成一个一个的个体
    //需求: 将如下集合进行扁平化
    val list3 = List(List(1,2,3) ,List(3,4,5) ,List(6,7) )
    println(list3.flatten)
    val list4 = List(List( List(1,2), List(3,4) ) ,List(List(3,4,5)) ,List(List(6) ,List(6,7) ))
    println(list4.flatten.flatten)
    //list.flatten
    println(list1.flatten)
    println("--------------------------")
    //43.flatMap: map + flatten
    //需求: 将如下集合中的元素拆分成一个一个的单词
    val list5 = List("Hello World", "Hello Scala" ,"Spark Hive")
    //map -> "Hello World" -> Array[Hello, World] -> flatten -> Hello , World
    println(list5.map(_.split(" ")).flatten)
    println(list5.flatMap(_.split(" ")))
    println("--------------------------")
    //44. filter : 过滤, 按照指定的规则从集合中过滤数据，将满足条件的返回
    //需求: 将如下集合中的偶数提取
    val list6 = List(1,2,3,4,5,6,7,8)
    println(list6.filter(_ % 2 == 0))
    println("--------------------------")

    //45.groupBy: 分组, 按照指定的规则将集合中的元素进行分组。 规则的计算结果作为key, 相同结果的元素为一组,作为Value
    //需求: 按照单词分组
    val list7 = List("Hello" , "World", "Hello", "Scala" ,"Spark", "Hive")
    println(list7.groupBy(word => word))

    //需求: 按照单词首字母分组
    println(list7.groupBy(_.substring(0, 1)))

    println("--------------------------")


    //46. sortBy:排序, 按照指定的规则对集合中的元素进行排序.
    //需求: 将如下集合按照数字大小从小到大排序
    val list8 = List(6,3,0,8,2,9,5,1)
    println(list8.sortBy(num => num))

    println(list8.sortBy(num => num)(Ordering.Int.reverse))


    val list9 = List((30,"zhangsan"),(20,"wangwu"),(20,"lisi"))
    //tuple的默认比较规则就是按照每个元素依次进行比较
    println(list9.sortBy(t  => t))
    println(list9.sortBy(t => t)(Ordering.Tuple2[Int, String].reverse))
    println(list9.sortBy(t => t)(Ordering.Tuple2[Int, String](Ordering.Int,Ordering.String.reverse) ) )

    // 47. sortWith：自定义比较

    val list10 = List("Scala" , "Hello" , "Hadoop", "Zookeeper", "Hive")
    //规则: 先比长度(升序)，后比字典序
    println(list10.sortWith(
      (str1, str2) => {
        if (str1.length == str2.length) {
          str1.substring(0, 1) < str2.substring(0, 1)
        } else {
          //比长度
          str1.length < str2.length
        }
      }
    ))

// 函数参数
    //1. 多个参数
    def fun1(name : String, age : Int ) : Unit = {
     println(s"name = $name , age = $age")
    }
    fun1("zhangsan",30)

    //2.可变参数
    //Java  : String ... args
    //Scala :  args : String*
    //可变参数只能声明一个， 且只能声明到参数列表的最后面.

    def fun2( names : String*  ): Unit = {
      println(names)
    }

    fun2()  //  List()
    fun2("zhangsan")  //WrappedArray(zhangsan)
    fun2("zs","ls","ww") //WrappedArray(zs, ls, ww)

    //3.参数默认值

    def registAccount( username : String ,  password : String = "000000" ) : Unit = {
      println(s"username = $username , password = $password")
    }

    registAccount("admin","123456")
    registAccount("root")

    //4. 带名参数
    def registAccount1( username : String ,  password : String = "000000" ,address : String ) : Unit = {
      println(s"username = $username , password = $password , address = $address")
    }

    registAccount1("admin" , "111111", "beijing")

    registAccount1("root" ,  address = "shanghai")

函数式编程至简原则

//1. 声明一个完整的函数
    def fun() : String = {
      return "fun"
    }
    //2. 至简原则
    //2.1 return关键字可以省略.
    def fun1() : String = {
      "fun1"
    }
    //2.2 如果函数体中只有一行语句,{}可以省略
    def fun2() : String = "fun2"
    //2.3 如果能自动推断出返回值类型， 返回值类型可以省略.
    def fun3() = "fun3"
    //2.4 如果函数没有参数， ()可以省略
    //如果函数声明的时候，没有写()，调用的时候一定不能写()
    //如果函数声明的时候，写了(), 调用的时候，()可以省略不写.
    def fun4 = "fun4"
    //2.5 返回值类型 + return(了解)
    // 如果函数中明确使用了return关键字，返回值类型不能省略.
    // 如果函数的返回值类型明确声明为Unit, 就算在函数中使用return关键字也返回不了结果
    // 如果函数的返回明确就是Unit,在函数中还使用了return关键字， 但是想把返回值类型省略掉
    // 可以将=一并省略 ,{}得有
    // 这种函数称之为过程函数.
    def fun5{return "fun5"}
    //2.6 省略 def 和 函数名
    //    匿名函数: (参数列表 ) => { 函数体 }
    //              (name:String, age:Int) => { println(xxxx)}
    //    函数类型: (参数类型) => 返回值类型
    //              (String,Int) => String
    var f = () => "fun6"

函数的类型比较重要类型指的是参数类型和返回值类型

匿名函数

 /*
    Scala - 函数式编程 - 匿名函数
    匿名函数的语法:  (参数列表) => { 函数体 }
     (name: String, age :Int ) => { xxxx }
    函数类型:  (参数类型) => 返回值类型
     String => String
     */
    def fun(f : String => String) : Unit = {
      println(f("zhangsan"))
    }
    def fparam(name : String) : String = {
      name toUpperCase
    }
    fun(fparam)
    // 函数作为值，重点关心函数的功能.
    fun((name : String) => name toUpperCase)
    println("-----------------------------------------------------")
    def fun1(f : (Int,Int) => Int) : Int = {
      f(10,20)
    }
    println(
      fun1(
        (i:Int , j: Int) => {i + j}
      )
    )

 //Scala - 函数式编程 - 函数作为值 - 赋值给变量
    def fun(name : String) : Unit = {
      println(name toUpperCase)
    }
    //调用函数
    fun("zhangsan")
    //将函数作为值赋值给变量时， 可以使用_来表示将函数当成整体赋值给某个变量
    var f = fun _
    f("lisi")
    //2:明确变量类型
    var ff : String => Unit = fun
    ff("wangwu")
    //Scala - 函数式编程 - 函数作为值 - 传递给参数
    def fun(name : String , f : String => String) : Unit = {
      println(f(name))
    }
    def ff(name : String) : String = {
      name.toUpperCase
    }
    fun("xiaodi",ff)
    println("---------------------------------------------")

    def fun1(f : (String , Int) => String ) : Unit = {
      println(f("xiaodi",18))
    }
    def info(name : String , age : Int) : String = {
      name + " " + age
    }
    fun1(info)
    // 声明一个函数，该函数的返回值是函数类型.
    def fun() : String => String = {
      info
    }

    def info(name : String) : String = {
      "xiaodi " + name
    }
    //函数作为返回值  因此返回的是一个函数还需要在传一个参数
    println(fun()("lcm"))

    /*
    Scala - 函数式编程 - 匿名函数
    匿名函数的语法:  (参数列表) => { 函数体 }
     (name: String, age :Int ) => { xxxx }
    函数类型:  (参数类型) => 返回值类型
     String => String
     */
    def fun(f : String => String) : Unit = {
      println(f("zhangsan"))
    }
    def fparam(name : String) : String = {
      name toUpperCase
    }
    fun(fparam)
    // 函数作为值，重点关心函数的功能.
    fun((name : String) => name toUpperCase)
    println("-----------------------------------------------------")
    def fun1(f : (Int,Int) => Int) : Int = {
      f(10,20)
    }
    println(
      fun1(
        (i:Int , j: Int) => {i + j}
      )
    )

    //Scala - 函数式编程 - 匿名函数 - 至简原则
    def fun( f : (Int , Int) => Int):Unit = {
      println(f(10,20))
    }
    //匿名函数
    fun( (i :Int, j : Int ) => { i + j } )
    //至简原则
    //1. 匿名函数的函数体只有一行语句, {}可以省略
    fun( (i :Int, j : Int ) =>   i + j  )
    //2. 匿名函数的参数类型可以省略
    fun( ( i , j  ) =>   i + j  )
    //3. 匿名函数的参数只有一个，()可以省略.
    //4. 匿名函数的参数在函数体中按照参数顺序只使用一次的情况下
    //   参数列表可以省略, =>一并省略掉
    //   通过_来表示参数
    fun(  _ + _  )
    println("--------------------------------------------")
    def fun1(f : String => String) : Unit = {
      println(f("atguigu"))
    }
    fun1(
      (name : String) => {name.toUpperCase}
    )
    //1. 省略{}
    fun1(
      (name : String) => name toUpperCase
    )
    //2. 省略参数类型
    fun1(
      name => name toUpperCase
    )
    //3. 省略()
    fun1(
      _ toUpperCase
    )

Scala - 函数式编程 - 闭包

//闭包:  内部函数使用了外部函数的局部变量，就形成了闭包现象。
    // Scala2.12.11 :将内部函数使用的外部函数的局部变量声明成内部函数的参数,
    //              外部函数调用内部函数时， 将外部函数的局部变量传入到内部函数

    //Scala2.11.8 : 将内部函数使用的外部函数的局部变量声明成内部函数的参数,
    //              将外部函数的局部变量提升成全局(成员变量)

    def outFun(i : Int) : Int => Int = {
      def innerFun(j : Int) : Int = {
        i + j
      }
      innerFun
    }
    println(outFun(10)(20))

 def main(args: Array[String]): Unit = {
   //Scala - 函数式编程 - 柯里化
    def regist(username:String ,password : String = "000000") : Unit = {
      println(s"username = $username , password = $password")
    }
    regist("xiaodi","123456")
    regist("lisi")
    //柯里化
    def regist1(username : String)(password  :String = "000000") : Unit = {
      regist1("zhangsan")("123456")
      regist1("lisi")()
    }
    //支持更多的语法
    implicit var newPassword : String = "666666"
    def regist2(username :String)(implicit password : String = "000000") : Unit = {
      println(s"username = $username, password = $password")
    }
    regist2("zhangsan")("123456")
    regist2("lisi")()
    regist2("lisi")

  }

 def main(args: Array[String]): Unit = {
   //Scala - 函数式编程 - 控制抽象
    //所谓的控制抽象就是支持将一段代码逻辑作为参数进行传递
    Breaks.breakable{
      for(i <- Range.inclusive(1,5)){
        if (i == 3){
          Breaks.break()
        }
        println("i = " + i)
      }
    }
    println("我咋办？")
    
    def myOp(op : => Unit) : Unit = {
      println(">>>>>>>>>>>>> START <<<<<<<<<<<<<<")
      op
      println(">>>>>>>>>>>>> STOP <<<<<<<<<<<<<<")
    }
    myOp{
      var i : Int = 20
      var j : Int = 30
      println( i + j )
    }

def main(args: Array[String]): Unit = {
   //Scala - 函数式编程 - 递归
    def sum(num : Int) : Int = {
      if (num == 1){
        1
      }else{
        num + sum(num - 1)
      }
    }
    // 尾递归思想
    def sum1(num : Int , result : Int) : Int = {
      if (num == 1){
        result
      }else{
        sum1(num -1 ,result + num)
      }
    }
    println(sum1(50000,1))
  }

 def main(args: Array[String]): Unit = {
    //1. 循环步长

    for(i <- 1 to 5 by 2 ){
      println(i)
    }

    /*
    for(i <- Range(1,5,2) ){
      println(i)
    }

     */

    println("----------------------------------")

    //2. 循环守卫
    //需求: 从1 循环到5 ,当循环到3的时候跳过本次循环
    // Scala中没有continue关键字。
    for(i <- 1 to 5){
      if(i != 3) {
        println(i)
      }
      /*
      if(i == 3){
        //跳过
        continue
      }
       */
    }

    for(i <- 1 to 5  if i != 3 ){

        println(i)
    }


    println("----------------------------------")

    //3.引入变量
    // 需求: 从1 循环到5 , 将每次循环的值+1后,赋值给另一个变量，并 输出
    for(i <- 1 to 5 ; j = i + 1 ){
      //var j = i + 1
      println(s" i = $i , j = $j")
    }

    println("----------------------------------")
    //4. 循环返回值
    // for循环默认的返回值为Unit
    // 通过yield关键字让for循环返回每次循环的结果
    var result =  for(i <- 1 to 5) yield {
      i + 1
    }

    println(result)

    //Thread.`yield`()


    println("----------------------------------")

    //5. 嵌套循环
    for( i <- 1 to 3 ){ // 1 2 3
      //外层循环体
      for(j <- 1 to 5 ){ // 1 2 3 4 5
        //内层循环体
         println(s"i = $i, j = $j")
      }
    }
    println("----------------------------------")

    for( i <- 1 to 3 ; j <- 1 to 5  ){ //  i = 1 2 3  j = 1 2 3 4 5
      //内层循环体
        println(s"i = $i, j = $j")
    }

    //字符串的输出
    println("*" * 3 )


    //6. 循环中断
    //需求: 从1循环到5,当循环到3的时候跳出循环.
    //Scala中没有break关键字.

    try{
      for( i <- 1 to 5 ){
        if(i == 3){
            throw new RuntimeException("退出吧.")
        }
        println(s"i = $i")
      }
    }catch{
      case ex : Exception => ex
    }
    println("我咋办???")

    println("----------------------------------")

    //Scala支持将一段代码逻辑作为参数传递给方法. 该现象叫控制抽象
    breakable {
      for (i <- 1 to 5) {
        if (i == 3) {
          break
        }
        println(s"i = $i")
      }
      println("haha")
    }

    println("我咋办???")

  }

Scala中的import: 1. 导入包下所有的类 import java.util._ 2. import可以在任意位置使用 3. import可以用来导包导类导对象. 4. import可以在一行中导入多个类 5. import可以用来屏蔽某个包下的类 6. import可以用来起别名 7. Scala import操作默认使用相对路径进行导入. 8. Scala默认导入如下内容: java.lang scala PreDef

2.
    import java.util._
    new ArrayList[String]

    3.
    导类
    import java.util.ArrayList
    new ArrayList[String]()

    导包
    import java.util
    new util.ArrayList[String ]

    导对象
    val user02 = new User02()
    println(user02.username)
    user02.testUser()

    import user02._

    println(username)
    testUser()

    4.
    import java.util.{ArrayList,HashMap,HashSet}
    new ArrayList[String]()
    new HashMap[String,String]

    5.
    import java.sql.{ Date=>_ ,_}
    import java.util._
    new Date()


    6.
    import java.sql.{Date=>SqlDate , _}
    import java.util.{Date=>UtilDate ,_}

    new SqlDate(System.currentTimeMillis())
    new UtilDate()

    7.
    import java.util.ArrayList
    val list = new ArrayList()
    println(list.getClass.getName)


    val arrayList = new _root_.java.util.ArrayList[String]
    println(arrayList.getClass.getName)

  def main(args: Array[String]): Unit = {
    /*
      创建对象的方式:
        1. new
        2. 工厂/反射
        3. 反序列化
        4. clone
        5. apply方法
           apply方法一般是声明在伴生对象中，用来创建伴生类的对象.
           Scala可以自动识别apply方法.

     */

    println(User07)  //com.atguigu.scala.chapter06.User07$@47f37ef1

    val user07 : User07 = User07()  // User07.apply()
    println(user07)


    println(User07("zhangsan"))

  }
}


//伴生类
class User07{}

//伴生对象
object User07{

  def apply(): User07 ={
    new User07()
  }

  def apply(name : String) : String = {
    name.toUpperCase
  }
}

object Scala08_constructor {
  def main(args: Array[String]): Unit = {
    /*
      Java中的构造器:
        [修饰符] 类名( 参数列表) { 构造体 }

      Scala中的构造器:

          1. 主构造器
               对象是通过主构造器创建出来的.
               主构造器跟类体整合到一起.
          2. 辅助构造器
              def this(){}
              辅助构造器必须直接或者间接的调用到主构造器
              被调用的辅助构造器一定要声明到调用者的前面。
          3. 主构造器和辅助构造器构成了重载
          4. 主构造器中的参数:
              如果通过var或者val声明， 参数就可以作为属性来使用。
          5. 构造器私有化
              class User08 private (var name : String ) {}
              private def this(){ }

     */

    val user08 = new User08

    val user088 = new User08("lisi")

    user088.name
  }
}

class User08 /*private*/ (var name : String ){

  //var username : String = name

  println("haha....")

  /*private*/ def this(){
    this("zhangsan")
  }

  def this(name:String, age:Int){
    this()
  }
}

//继承
object Scala09_extends {
  def main(args: Array[String]): Unit = {
    val user09 = new User09("zhangsan")
  }
}

class Parent09(name : String ){
  println("Parent09...")

  /*
  def this(){
    this("zhangsan")
  }
   */
}

class User09(name :String ) extends Parent09(name) {
  println("User09...")
}

Scala中的抽象:
    1. 抽象类
    2. 抽象方法
        子类将抽象类中的抽象方法补充完整， override关键可加可不加
        子类重写抽象类中的具体方法， override关键字必须要加.
    3. 抽象属性
        子类将抽象类中的抽象属性补充完整， override关键可加可不加
        子类重写抽象类中的具体属性， override关键字必须要加.
        var声明的具体属性不允许被重写。

abstract  class User10{

  //声明抽象属性(本质上是抽象方法  get、set)
  var username : String
  val password : String

  //具体属性
  var age : Int  = _

  val sex : String = "man"


  //声明抽象方法
  def testAbastractMethod() : Unit  // = {}

  //具体方法
  def testMethod():Unit = {
    println(" testMethod ... User10 ")
  }
}

//具体类

class SubUser10 extends User10{
  //补全抽象属性
  override var username: String = _
  override val password: String = "123456"

  //重写具体属性
  //var声明的具体属性不允许被重写.
  //override var age : Int = 40

  override val sex: String = "female"


  //补全抽象方法
  override  def testAbastractMethod(): Unit = {
    println("testAbastractMethod")
  }

  //重写具体方法
  override def testMethod(): Unit = {
    println("testMethod ... SubUser10")
  }
}

特质

object Scala11_trait {
  def main(args: Array[String]): Unit = {
    /*
        Java中的接口:    interface   =>  implements      => 实现接口
        Scala中的特质:   trait       =>  extends + with  => 混入特质

     */

    val mysql11 = new MySQL11

    mysql11.operData()
    mysql11.insert()

    //动态混入特质
    val oracle11 =
                      new Oracle11() with Operator11 with DB

    oracle11.operData()
    oracle11.insert()


  }
}

//声明特质
trait Operator11{
  //抽象属性 抽象方法  具体属性  具体方法
  def operData(): Unit ={
    println("操作数据")
  }
}

trait DB{
  def insert(): Unit = {
    println("插入数据")
  }
}


//静态混入特质
class MySQL11  extends Operator11 with DB {

}

class Oracle11{

}

//Scala - 面向对象编程 - 特质
object Scala12_trait {
  def main(args: Array[String]): Unit = {
    val mySql12 = new MySQL12
    //初始化顺序: 按照混入特质的顺序从左到右进行初始化

    val mysql122 = new MySQL122
    mysql122.operData()

    //功能调用: 按照混入特质的顺序从右往左进行调用
    // super: 指的是上一级特质
    // super[特质名] : 指的是指定的特质
  }
}
trait Operate122{
  def operData():Unit={
    println("操作数据。。")
  }
}
trait DB122 extends Operate122{
  override def operData(): Unit = {
    print("向数据库中。。")
    super.operData()
  }
}
trait Log122 extends Operate122{

  override def operData(): Unit = {
    print("向日志中。。")

    //super.operData()
    super[Operate122].operData()
  }
}
class MySQL122 extends DB122 with Log122 {

}



trait Operator12 {
  println("operator...")
}
trait DB12 {
  println("db...")
}
class MySQL12 extends DB12 with Operator12{
  println("mysql...")
}

单例

object Scala13_singleton {
  def main(args: Array[String]): Unit = {
    /*
      单例: 一个类只能被创建一个对象.

      Java中的单例:
         1. 构造器私有
         2. 静态方法，用来获取对象.


      Scala中的单例:
         1. 构造器私有

         2. 用来获取对象的方法.

     */

    //val user13 = new User13

    val user131 = User13()

    val user132 = User13()

    println(user131 eq user132)

  }
}

class User13 private {

  /*
   var user : User13 = null

   def getObj(): User13 = {
      if(user == null ){
        user = new User13
      }
      user
   }

   */
}

object User13{

  //伴生对象可以访问伴生类的私有内容.

  /*
  var user : User13 = null
  def apply() : User13 = {
    if(user == null ){
        user = new User13
    }
    user
  }

  */

  val user = new User13

  def apply() : User13 = {
    user
  }

}

扩展：反射枚举应用

object Scala14_ext {
  def main(args: Array[String]): Unit = {
    //1. 类型判断和转换
    // 判断: isInstanceOf[类型]
    // 转换: asInstanceOf[类型]

    //2. 获取Class对象
    val c1: Class[_] =
          Class.forName("com.atguigu.scala.chapter06.User14")
    println(c1)

    val user14 = new User14
    val c2: Class[_ <: User14] = user14.getClass
    println(c2)

    //User14.class

    val c3: Class[User14] = classOf[User14]
    println(c3)

    //3. type定义新类型（取别名）
    // type String        = java.lang.String

    type MyString = java.lang.String

    val myStr = new MyString("abc")
    println(myStr)

    //4. 枚举类
    // 枚举类
    println(Color.RED)
    println(Color.RED.id)


    //5. 应用类

  }
}

class User14{}

//枚举
object Color extends Enumeration {
  val RED = Value(1, "red")
  val YELLOW = Value(2, "yellow")
  val BLUE = Value(3, "blue")
}


// 应用类
object AppTest extends App {
  println("application");
}