Scala 变量-函数-循环-数组-List-元组-Set-Map 讲解

package com.zhu.scala

/**
  * Created by zhuhailong-dc on 2017/3/3.
  * 1.定义变量
  * 2.定义函数
  * 3.定义循环
  * 4.定义数组
  * 5.定义List
  * 6.定义元组
  * 7.定义Set
  * 8.定义Map
  *
  */

class Scala_2(){
  private var sum=1

  //Scala中方法参数的一个重要特征是它们都是val,而不是var
  def add(b:Byte):Unit={
    sum+=b
  }
  def add2(b:Byte):Unit=sum+=b

  //如果没有发现任何显式的返回语句,Scala方法将返回当前方法中最后一个计算得到的值
  def checksum():Int={
    return ~(sum & 0xff)+1
  }
  // = ~ 之间要有空格
  def checksum2():Int= ~(sum & 0xff)+1
}

object Scala_2 {
  def main(args: Array[String]): Unit = {
    //1. 定义变量--采用类型推断
    val msg = "Hello,World!"
    //println(msg)

    //--指定类型
    val msg2: String = "Hello,World!"
    val msg3: java.lang.String = "Hello,World!"
    //println(msg3)

    var greeting = "Hello,World!"
    greeting = "Leave me alone,world!"
    //println(greeting)

    val obj = new Scala_2
    obj.add(12)
    //println(obj.checksum())

    //2. 定义函数
    def f(): Unit = "this string gets lost"

    def g() {
      "this string gets lost"
    }

    def h() = {
      "this string gets lost"
    }

    //println(f()) // 输出结果为()
    //println(g()) // 输出结果为()
    //println(h()) // 输出结果为 this string gets lost

    def max(x: Int, y: Int): Int = {
      if (x > y) {
        x
      } else {
        y
      }
    }

    def max2(x: Int, y: Int) = if (x > y) x else y

    def greet() = "h"

    // println(greet) 输出结果为h
    def greet2() = println("h") //println(greet2) 输出结果为 h () 是因为该方法是没有返回值的


    //3. 定义循环
    var i = 0
    while (i < 10) {
      //println(i)
      i += 1
    }

    var str: Array[String] = new Array[String](10)
    //Array[String]("console","is","nice").foreach(arg=>println(arg))
    //Array[String]("console","is","nice").foreach((arg:String)=>println(arg))
    //Array[String]("console","is","nice").foreach(println)

    for (arg <- Array[String]("console", "is", "nice")) {
      //println(arg)
    }


    //4. 定义数组
    val greetString = new Array[String](3)
    /**
      * 当你在一个或多个值或变量外使用括号时,Scala会把它转换成对名为apply的方法的调用,于是greetString(i)转换成greetString.apply(i)
      * 这个原则不仅仅局限于数组:任何对某些在括号中的参数的对象的应用将都被转换为对apply方法的调用.当然前提是这个类型实际定义过apply方法
      *
      */
    greetString(0) = "hello"
    greetString(1) = ","
    greetString(2) = "world"
    for (i <- 0 to 2) {
      //println(greetString(i))
    }

    val num1 = Array("1", "2", "3")
    val num2 = Array.apply("4", "5", "6")
    for (i <- 0 to 2) {
      //println(num1(i))
    }

    for (i <- 0 to 2) {
      //println(num2(i))
    }


    //5. 定义List
    val list1 = List(1, 2, 3)
    /**
      * scala中List是不可变得,表现上有些像Java的String:当你在一个List上调用方法时,似乎这个名字指向的List看上去被改变了,而实际上它只是用新的的值创建了一个List并返回
      * :::用于List集合之间的拼接
      * :: 把一个新元素组合到List 并且是拼接在最前面
      * Nil要最后才能使用 :: 被定义在List类上的方法
      *
      * 为什么List不支持append?
      * List没有提供append操作,因为随着列表边长append的耗时将呈线性增长,而使用::做前缀则仅需要花费常量时间.如果你想通过添加元素来构造列表
      * 你的选择是把它们前缀进去,当前完成之后再调用reverse;或使用ListBuffer,一种提供append操作的可变列表,当你完成之后再调用toList
      */
    val list2 = List(4, 5, 6)
    val list3 = list1 ::: list2
    //println(list3)

    val tmp=list3.::(1)
    val tmp2=1::list3
    //println(tmp)
    //println(tmp2)

    val tmp3=1::2::3::4::Nil
    //println(tmp3)


    //6. 定义元组
    var pair=(1,2,"a","b")
    //println(pair._1)
    //println(pair._2)
    //println(pair._3)
    //println(pair._4)


    //7. 定义Set
    var set1=Set("a","b")
    set1+="c"
    //println(set1.contains("c"))

    //引用了可变Set  --作用域是下面所有的代码,如果想之后再引入不可变的,需要重新引用不可变的包
    import scala.collection.mutable.Set
    val set2=Set("d","e")
    set2+="f"
    //println(set2)


    //import scala.collection.immutable.Set
    val set3=Set("i","g")
    set3+="h"
    //println(set3)

    //8. 定义Map
    /**
      * Map是Scala里另一种有用的集合类,和Set一样,Scala采用了类继承机制提供了可变的和不可变的两种版本的Map
      * scala.collection包里面有一个基础的Map特质和两个子特质Map
      * 可变的Map在scala.collection.mutable里,不可变的在scala.collection.immutable里
      * 一般来说坐标，数组从0开始,其他的大部分都是从1开始
      */
    import scala.collection.mutable.Map
    val map1=Map[Int,String]()
    map1+=(1->"Go to island")
    println(map1(1))



  }
}