大数据学习——scala入门练习

package com

/**
  * Created by ZX on 2015/11/6.
  */
object VariableDemo {
  def main(args: Array[String]) {

    //1定义变量-----------------------------------------
    //使用val定义的变量值是不可变的，相当于java里用final修饰的变量
    val i = 1
    //使用var定义的变量是可变得，在Scala中鼓励使用val
    var s = "hello"
    //Scala编译器会自动推断变量的类型，必要的时候可以指定类型
    //变量名在前，类型在后
    val str: String = "itcast"
    println(i);
    println(s);
    println(str);

    //2循环-----------------------------------------
    for (c <- s) println(c);

    //3Array
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    for (e <- arr)
      println(e)

    for (i <- 1 to 10) println(i)

    //4高级for循环
    //每个生成器都可以带一个条件，if前面没有分号
    for (i <- 1 to 3; j <- 1 to 3 if i != j)
      println((10 * i + j) + " ")

    //5for推导式：如果for循环的循环体以yeild开始，则该循环会构建一个组合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i * 10
    println(v)

    println((1 to 10).map(_ * 10))

    val a = Array("a", "b", "c")
    for (e <- a) println(e)

    for (i <- 0 to a.length) println(i)
    for (i <- 0 until a.length) println(a(i))



    //判断x的值，将结果赋给y
    val x = 0
    val y = if (x > 0) 1 else -1
    println(y)

    //支持混合类型表达式
    val z = if (x > 1) 1 else "error"
    println(z)

    //如果缺失else，相当于if(x>2) 1 else ()
    val m = if (x > 2) 1
    println(m)


    //操作符重载
    val numa = 2
    val numb = 3
    numa + numb
    numa.+(numb)



    //方法和函数
    //定义方法
    def m1(x: Int): Int = x * x
    //scala可以自动推断返回值类型，但是如果方法中存在递归，则必须指定返回值类型
    def m2(x: Int) = x * x
    println("-----------" + m1(2))
    println("-----------" + m2(2))


    def n1(y: Int, z: Int): Unit = println(y + z)
    val n2 = n1(1, 2)
    println("n2是" + n2) //n2是() scala中的()相当于java中void

    def n3(y: Int, z: Int) {
      println(y + z)
    }
    val n4 = n3(2, 2)
    println("n4是" + n4)

    //定义函数 函数可以作为参数传入方法里边
    val f = (x: Int) => x * x;
    println("-----------" + f(3))
    val f1 = (x: Int, y: Int) => x * y
    println("-----------" + f1(3, 4))

    val arrs = Array(1, 2, 3, 4, 5)
    arrs.map((x: Int) => x * 10)
    arrs.map((x) => x * 10)
    arrs.map(x => x * 10)
    for (e <- arrs) println(e)
    val arr1 = Array(1, 2, 3);

    val arr2 = arr1.map(_ * 10)
    for (e <- arr2) println(e)


    //函数作为函数的参数传给函数
    val ff1 = (x: Int) => x * x
    val arr3 = arr2.map(ff1)

    for (e <- arr3) println("---" + e)
  }
}