scala随笔

object loopDemo2 extends App {
  def foo(x:Int):Int = {
    println(x)
    x * x
  }

  def byValue(fn:Any):Unit = {
    println("----------")
    println(fn)
    println(fn)
  }

  def byName(fn: => Any):Unit = {
    println("*************")
    println(fn)
    println(fn)
  }

  byName(foo(5))
  byValue(foo(5))

  //map 逐条处理  逐条返回
  //foreach  无返回值
  //to  从1到10包含最后一位
  //until 从1到10不包含最后一位
  //by 步长
  //filter  过滤
  (1 to 10 ) filter (x => {
    val flag = x % 2 != 0
    flag
  }) map( x => {
    val rs = x * 2
    s"$x * 2 = $rs"
  }) foreach(println(_))
  //for循环
  for (i <- 1 to 10){
    println(i)
  }
  //不介意使用  break
  //Null引用数据类型  不能被访问的任意值类型的对象
  //Nothing 不是任何类型的实例
  //Unit    无返回值  是一个类 表示方法无返回值
  //实用数据类型   Tuples 元组
  //python元组  一旦初始化  不允许被修改
  //Scala的元组  一旦初始化 不允许被修改，但是Scala的元组的长度最大不能超过22

  val t = Tuple3(1,2,3)
  t.productIterator.foreach(x => {
    val s = x.toString.toInt + 2
    println(s)
  })
  val (a,b,c) = t
  println(c)

  val t2 = a -> c
  println(t2.getClass)
  println(t2)
//集合
  //分为可变集合和不可变集合
  //不可变集合
  val aa = List(1,2,3)
  println(aa(2))

 val a1 = Array(1,2,3)
  val a2 = Array(11,22,33)
  println(a1)
  (a1 ++ a2).foreach(println(_))
  //冒号在数组的那一边
  //都是一个函数一个方法
val a3 = a1:+ 4
//  val a3 = 4 +:a1
  a3.foreach(println(_))
  //逆序输出list内容
  val a4 = List(11,22,33)
  val a5 = a4.reverse
  println(a5)
//转换list  groupBy 分组
  val a6 = (1 to 10 by 2).toList
  println(a6.groupBy(_ % 2 == 0))
  //只打印偶数  getOrElse 要么得到   要么执行下一个选项
  val a7 = a6.groupBy(_ % 2 == 0)
  a7.getOrElse(true,List(2,2,2,2)).foreach(println(_))
//从小到大排序
 val a8 = List(9,1,7,2,6,3,4,8,5)
  println(a8)
  val a9 = a8.sorted
  println(a9)
  //两个参数的tupres
  val a10 = List("a" ->4,"b" ->2,"c" ->1)
  println(a10)
  //自定义排序方法
  val a11 = a10.sortWith((x,y) => {
    x._2 < y._2
  })
  println(a11)
  //分组
val l = List[Int](2,3,4,6,8,9,11,15)
  val x = l grouped 3
 println(x.next())
  println(x.next())
  println(x.next())
//取数
  var y = l sliding 6
  println(y.next())
  println(y.next())
  println(y.next())

//复习python并集
  //集合并集
  var s = Set("ab","yz","123")
  var tt = Set("ab","gh","mn","st","yz")
//交集
  var j = s intersect tt
  println(j)
//追加数据
  s += "xyz"
  println(s)
  //删除数据
  s -= "xyz"
  println(s)
  //取值
  val s1 = Map("cn"->"中国","usa"->"美国","jp"->"日本")
println(s1)
  println(s1.getOrElse("cnn","没有这个国家"))
//流的处理
  val s2 = 1 #:: 2 #:: 3 #:: Stream.empty
  println(s2.length)
  val s3 = s ++ Stream[Int](4)
  println(s3)
//叠加  叠加后的值放在第一位
  //折叠算法  /对应的是计算后的到值所对应的位置
  val s5 = (5 /: s2)(_+_)
  val s6 = (s2 :\ 5)(_+_)
  println(s5)
  println(s6)
//枚举  就是常量  不可修改
//list集合的求方和
  def chuli(x:Int):List[Int] = {
    List(Math.pow(x,1).toInt,Math.pow(x,2).toInt,Math.pow(x,3).toInt)
  }
  val a12 = List(1,2,3,4)
  a12.map(chuli).foreach(println(_))

  //Null 和 null
  //Null 是一个类型
  //null  是一个值
  def mytry(a:Null):Unit = print("Null type...")
  //只能传null  只能传值是null的值
  val a13 = null
  mytry(a13)

  //Nothing
  //有对象不能有实例
 // val List[String] = List[Nothing]("abc")

  //Nil 和 None