import java.util.Date

class ScalaTest1 {

}

//在scala里面沒有static關(guān)鍵詞的,在 object修改的代碼塊中定義的方法或者變量或者常量都是靜態(tài)的
object ScalaTest1{
  def main(args: Array[String]) {
    //常量
    val name:String = "hello scala"
    //變量
    var age = 10
    println(name + "\t" + age)

    var person=new Person(name,age)
    person.hello()
  }
}

class Person(param1:String,param2:Int){
    var name=param1
    var age=param2
  //Unit 表示沒有返回值等同于void
  def hello():Unit={
    print("名稱為："+name+"\t"+age)
  }
}

object ScalaTest2{
  def main(args: Array[String]): Unit = {
    //if else
    var age=18
    if (age<18){
      println("18歲")
    }else if (18<=age && age<=20){
      println("18-20之間")
    }else{
      println("大于20")
    }

    //for循環(huán)
    for (i<- 1 to 10){
      println(i)
    }
    for (i<- 1 until 10){
      println(i)
    }
    //i<- 1 to 10 代表 將1 到10 的數(shù)據(jù)復(fù)制給i(包括10)
    //i<- 1 until 10 代表 將1 到10 的數(shù)據(jù)復(fù)制給i(不包括10)

    //雙層for循環(huán)
    for (i<- 1 to 10;j<- 1 until 10){
      println("i="+i+"j="+j)
    }
    //for循環(huán)加判斷打印偶數(shù)
    for (i<-1 to 10;if (i%2==0)){
      println(i)
    }
    //scala 可以不用寫分好

    //for循環(huán)的yield關(guān)鍵詞用法，將每次迭代的數(shù)值存入一個(gè)list數(shù)組中
    val list = for(i <- 1 to 10 ; if i % 2 == 0) yield i
    for(elem <- list){
      println(elem)
    }

    //while循環(huán)
    //scala中不能使用count++，count--只能使用count = count+1 ，count += 1
    var index = 0
    while(index < 100 ){
      println("第"+index+"次while 循環(huán)")
      index += 1
    }

    //這是一個(gè)完整版的函數(shù)
    def fun1(a:Int,b:Int):Int = {
      return a+b
    }
    //這是一個(gè)簡化版的函數(shù)   最后一行語句的執(zhí)行結(jié)果就是這個(gè)函數(shù)的返回值
    def fun1_01(a:Int,b:Int) = {
      a+b
    }
    println(fun1(1,2))
    println(fun1_01(1,2))

    //創(chuàng)建一個(gè)帶有默認(rèn)值參數(shù)的函數(shù)   函數(shù)中參數(shù)的默認(rèn)修飾符是val
    def fun2(a:Int,b:Int=10,c:Int = 20)={
      a+b+c
    }
//    println(fun2(1))
//    println(fun2(1,2,3))

    //創(chuàng)建一個(gè)可變參數(shù)長度的函數(shù)
    def fun3(elems:Int*)={
      for(elem <- elems){
        println(elem)
      }
    }
    fun3(1,2,3,4,5,6,7,8,9)

    //遞歸函數(shù)    求解5 的階乘   推測類型 需要有依據(jù) 找不根據(jù)推測不出類型的
    def fun4(num:Int):Int = {
      if(num == 1){
        num
      }else{
        num * fun4(num - 1)
      }
    }
    println(fun4(5))

    //匿名函數(shù) ： 沒有名字的函數(shù)
    val fun5 = (name:String,facePower:Double) => {
      println(name + "\tfacePower:" + facePower)
    }
    fun5("scala",100)

    //偏應(yīng)用函數(shù)是一種表達(dá)式，不需要提供函數(shù)需要的所有參數(shù)，只需要提供部分，或不提供所需參數(shù)
    def log(date:Date,log:String) = {
      println(date + "\t" + log)
    }

    //在調(diào)用log函數(shù)的時(shí)候  每次都需要傳入一個(gè)date對(duì)象  煩
    val date = new Date()
    log(date,"log1")
    log(date,"log2")
    log(date,"log3")

    val logWithDate = log(date,_:String)
    logWithDate("log1")
    logWithDate("log2")
    logWithDate("log3")


    /**
      * 什么是高階函數(shù)？
      *   函數(shù)的參數(shù)是函數(shù)，或者函數(shù)的返回類型是函數(shù)，或者函數(shù)的參數(shù)和函數(shù)的返回類型是函數(shù)的函數(shù)
      *   scala支持面向函數(shù)編程
      *   scala支持面向?qū)ο笞兂?      *
      *   fun6函數(shù)的參數(shù)要一個(gè)函數(shù)  要一個(gè)什么樣的函數(shù)？
      */
    def fun6(f:(Int,Int) => Int):Int = {
      f(100,200)
    }
    def f(a:Int,b:Int) = {
      a+b
    }
    println(fun6(f))

    //原則：匿名函數(shù)中參數(shù)在函數(shù)體中只出現(xiàn)一次可以用_代替
    println(fun6((a:Int,b:Int)=>{a+b}))
    println(fun6((_+_)))


    val str1 = "hello scala1"
    val str2 = "hello scala2"
    val str3 = "HELLO scala3"
    println(str1.indexOf('o'))

    println(str1.equals(str3))
    //不區(qū)分大小寫
    println(str1.equalsIgnoreCase(str3))

    //創(chuàng)建一個(gè)可變長度的字符串
    val strBuilder = new StringBuilder
    strBuilder.+('F')
    strBuilder.++=("Hello")
    strBuilder ++= "  World"
    strBuilder.append(" Scala")
    strBuilder += ('P')
    println(strBuilder)


    //創(chuàng)建了一個(gè)長度為10的數(shù)組   數(shù)組中元素的類型必須是Int
    val arr = new Array[Int](10)

    for(index <- 0 until arr.length){
      arr(index) = index * index
    }

    arr.foreach((x:Int)=>{
      println(x)
    })
    //簡化版
    arr.foreach(println)


    //List集合
    val list1 = List(1,2,3,4,5,6,7,8,9)
    list1.foreach(println)
    //    ?filter:過濾元素
    def fl(x:Int):Boolean={
      x > 3
    }

    println("=============================================================")
    var filtered = list.filter(fl)
    filtered.foreach(println)
    filtered = list.filter((x:Int) =>x > 3)
    filtered.foreach(println)

    //    ?count:計(jì)算符合條件的元素個(gè)數(shù)
    val count = list.count((x:Int) => {
      x > 1
    })
    println(count)

    //    ?map：對(duì)元素操作
    val list2 = List("hello 11111","hello 22222","hello 33333")
    //map函數(shù)傳入的匿名函數(shù)的參數(shù)的類型一定是與集合中元素的類型一致
    //map函數(shù)傳入的匿名函數(shù)的返回值的類型就是這個(gè)新集合的泛型
    val rest = list2.map((x:String) => {
      x.split(" ")
    })
    rest.foreach((x:Array[String])=>{
      x.foreach(println)
    })
    //    ?flatmap ：壓扁扁平,先map再flat
    val rest1 = list2.flatMap((x:String) => {
      x.split(" ")
    })
    rest1.foreach(println)



    //set集合
    val set1 = Set(1,2,3,4,4)
    val set2 = Set(1,2,5)
    //交集   scala中字符有可能也是方法名
    val rest3 = set1.intersect(set2)
    val rest4 = set1.&(set2)
    rest4.foreach(println)

    println("===============取兩個(gè)集合的差集===================")
    //取兩個(gè)集合的差集   在set1集合中存在的但是set2集合中沒有的元素
    set1.diff(set2)
    set1.&~(set2).foreach(println)

    val str = set1.mkString("~")
    println(str)

    set1.max
    set1.min

    set1.toList


    val map = Map(
      "1" -> "scala",
      2 -> "scala1",
      (3,"scala2")
    )
    val keyIterator = map.keys.iterator
    while(keyIterator.hasNext){
      val key = keyIterator.next()
      println(key + "====" + map.get(key).get)
    }

    println(map.get("1"))
    println(map.get("1000").getOrElse("no result"))

    map.foreach((x:(Any,String)) => {
      val key = x._1
      val value = x._2
      println("key:" + key + "\tvalue:" + value)
    })

    println(map.contains("1"))




    //============================Tuple============================
    val t2 = (1,2)
    val t3 = Tuple3(1,2,3)
    val t4 = Tuple4("scala",1,true,1.0)
    val t44 = ("scala1",1,true,1.0)
    println(t2._2)
    val iterator = t44.productIterator
    while(iterator.hasNext){
      //在循環(huán)體內(nèi)不要調(diào)用多次next方法
      println(iterator.next())
    }
    //二元組對(duì)象才有swap：調(diào)換位置
    val s2 = t2.swap
    println(s2._1)

    //============trait==============================
    /**
      * trait可以類比成java中的接口  但是比java接口更高級(jí)一些
      *   trait中可以定義方法也可以實(shí)現(xiàn)方法
      */
    val s = new Student
    s.read("scala")
    s.listen("I Like")
    s.sayName("scala Like")
  }

}

trait Read {
  def read(name:String){
    println(name+" is reading")
  }

  def sayName(name:String):String
}

trait Listen {
  def listen(name:String){
    println(name + " is listenning")
  }
}

class Student extends Read with Listen{
  override def sayName(name: String): String = {
    println("say you:" + name)
    name
  }
}