import java.util.Date

class ScalaTest1 {

}

//在scala里面没有static关键词的,在 object修改的代码块中定义的方法或者变量或者常量都是静态的
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循环
    for (i<- 1 to 10){
      println(i)
    }
    for (i<- 1 until 10){
      println(i)
    }
    //i<- 1 to 10 代表 将1 到10 的数据复制给i(包括10)
    //i<- 1 until 10 代表 将1 到10 的数据复制给i(不包括10)

    //双层for循环
    for (i<- 1 to 10;j<- 1 until 10){
      println("i="+i+"j="+j)
    }
    //for循环加判断打印偶数
    for (i<-1 to 10;if (i%2==0)){
      println(i)
    }
    //scala 可以不用写分好

    //for循环的yield关键词用法，将每次迭代的数值存入一个list数组中
    val list = for(i <- 1 to 10 ; if i % 2 == 0) yield i
    for(elem <- list){
      println(elem)
    }

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

    //这是一个完整版的函数
    def fun1(a:Int,b:Int):Int = {
      return a+b
    }
    //这是一个简化版的函数   最后一行语句的执行结果就是这个函数的返回值
    def fun1_01(a:Int,b:Int) = {
      a+b
    }
    println(fun1(1,2))
    println(fun1_01(1,2))

    //创建一个带有默认值参数的函数   函数中参数的默认修饰符是val
    def fun2(a:Int,b:Int=10,c:Int = 20)={
      a+b+c
    }
//    println(fun2(1))
//    println(fun2(1,2,3))

    //创建一个可变参数长度的函数
    def fun3(elems:Int*)={
      for(elem <- elems){
        println(elem)
      }
    }
    fun3(1,2,3,4,5,6,7,8,9)

    //递归函数    求解5 的阶乘   推测类型 需要有依据 找不根据推测不出类型的
    def fun4(num:Int):Int = {
      if(num == 1){
        num
      }else{
        num * fun4(num - 1)
      }
    }
    println(fun4(5))

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

    //偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数
    def log(date:Date,log:String) = {
      println(date + "\t" + log)
    }

    //在调用log函数的时候  每次都需要传入一个date对象  烦
    val date = new Date()
    log(date,"log1")
    log(date,"log2")
    log(date,"log3")

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


    /**
      * 什么是高阶函数？
      *   函数的参数是函数，或者函数的返回类型是函数，或者函数的参数和函数的返回类型是函数的函数
      *   scala支持面向函数编程
      *   scala支持面向对象变成
      *
      *   fun6函数的参数要一个函数  要一个什么样的函数？
      */
    def fun6(f:(Int,Int) => Int):Int = {
      f(100,200)
    }
    def f(a:Int,b:Int) = {
      a+b
    }
    println(fun6(f))

    //原则：匿名函数中参数在函数体中只出现一次可以用_代替
    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))
    //不区分大小写
    println(str1.equalsIgnoreCase(str3))

    //创建一个可变长度的字符串
    val strBuilder = new StringBuilder
    strBuilder.+('F')
    strBuilder.++=("Hello")
    strBuilder ++= "  World"
    strBuilder.append(" Scala")
    strBuilder += ('P')
    println(strBuilder)


    //创建了一个长度为10的数组   数组中元素的类型必须是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:计算符合条件的元素个数
    val count = list.count((x:Int) => {
      x > 1
    })
    println(count)

    //    map：对元素操作
    val list2 = List("hello 11111","hello 22222","hello 33333")
    //map函数传入的匿名函数的参数的类型一定是与集合中元素的类型一致
    //map函数传入的匿名函数的返回值的类型就是这个新集合的泛型
    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("===============取两个集合的差集===================")
    //取两个集合的差集   在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){
      //在循环体内不要调用多次next方法
      println(iterator.next())
    }
    //二元组对象才有swap：调换位置
    val s2 = t2.swap
    println(s2._1)

    //============trait==============================
    /**
      * trait可以类比成java中的接口  但是比java接口更高级一些
      *   trait中可以定义方法也可以实现方法
      */
    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
  }
}