大数据之Scala

scala底层就是java；spark底层是scala写的

object Demo12 {
  def main(args: Array[String]): Unit = {
    println("aa")
  }

}

/*
* object是静态的
* 里面的mian方法也是静态的
* extends App 里面可以不写main方法
* */
object Demo11 extends App {
  println("wnn")
}

//变量的定义，不初始化赋值会报错
    var age :Int =18
    var name :String = "wnn"
    var gender :String ="女"

var address="上海"
    println(address.isInstanceOf[String])//返回true 或者false

// 定义变量 使用val 变量不可变
// 静态的 效率高 安全
// 定义变量的时候优先使用val定义变量
// 如果变量后续的会发生改变 才使用var修饰

import java.util.Random
object Demo3 {
  def main(args: Array[String]): Unit = {
    val random = new Random()
    val number: Int= random.nextInt(10)
    println("当前的数字是："+number)
    if(number>5){
      println("大于5")
      if(number%2==0){
        println("大于5的偶数")
      }else{
        println("大于5的奇数")
      }
    }else{
      println("小于5")
      if(number%2==0){
        println("小于5的偶数")
      }else{
        println("小于5的奇数")
      }
    }
  }
}

//多分支流程控制
import java.util.Random
object Demo2 {
  def main(args: Array[String]): Unit = {
    //随机获取一个数组的脚标
    val random = new Random()
    //使用java的类
    val index: Int= random.nextInt(5)
    println("当前的脚标是："+index)
    //定义一个数组
    val arr = Array[String]("A", "B", "C", "D", "E")
    //数组根据脚标获取土元素
    val element : String = arr(index)
    //元素的比较
    if("A".equals(element)){
      println("a")
    }else if ("B".equals(element)){
      println("b")
    }else if ("C".equals(element)){
      println("c")
    }else if ("D".equals(element)){
      println("d")
    }else{
      println("e")
    }
  }

}

//值匹配
import java.util.Random
object Demo4 {
  def main(args: Array[String]): Unit = {
    val arr = Array[String]("A","B","C","D","E")
    val random = new Random()
    val index: Int= random.nextInt(5)
    println("随机获取的当前的脚标是"+index)
    val element :String = arr(index)
    // 匹配模式  匹配值
    element match {
      case "A" => println("a")
      case "B" => println("b")
      case "C" => println("c")
      case "D" => println("d")
      case "E" => println("e")
      case _ => println("OTHER")

     }
  }

}

 for(i <- 1 to 10){
       println(i)//[1,10]
     }
    for(i <- 1 until  10){
      println(i)//[1,10)
    }

遍历下标

val arr = Array[Int](1, 2, 3, 4, 5, 6, 7, 8, 9)
    for(index <- 0 until  arr.length){
      println(index)
    }
    for (index1 <- 0 to arr.length-1){
      println(index1)
    }

遍历数组

val arr = Array[Int](1, 2, 3, 4, 5, 6, 7, 8, 9)
//第一种
    for(index <- 0 until  arr.length){
      println(arr(index))
    }
    for (index1 <- 0 to arr.length-1){
      println(arr(index1))
    }
    //第二种
    for(e <- arr){
      println(e)
    }

object Demo6 {
  def main(args: Array[String]): Unit = {
   for(i <- 1 to 9 ;j <- 1 to i){
      print(s"$j * $i = " +i*j+"\t")
      if(i==j){
        println
      }
    }
  
  }
}

// 步进
for(i <- 1 to 10 by 2)  // 1 3 5 7 9
// 守卫模式，有约束条件
for(i <-  1 to 10  if i%2==1 && i>5) //  7 , 9
// 推导式 关键字 yields
 val res  = for(i<-1 to 10 if i%2==0 && i>5) yield i
    for(e <- res){
     println(e)
    }
// 推导式 对元素进行再次运算
for(i <-  1 to 10  if i%2==1 && i>5) yield i*100  //[700, 900]

def  mname(参数类型列表):返回值类型={
    //...
    // 最后一行是返回值
}
调用 
object中的直接调用
类中的 new 类 . 方法

类中定义

class MyMethod {
  // 定义方法
   // 普通的方法  对象.方法名(实参)
  def  twoStrToUpperThenConcat(str1:String,str2:String):String={
    val res =  str1.toUpperCase+"--"+str2.toUpperCase
     res
   }
}

  // 方法  没有参数  () 省略
  def show() ={
    println("show....")
  }
  // 可变的参数类型列表
  def sum(x:Int*):Unit ={
    var sum = 0
    for (elem <- x) {
      sum+=elem
    }
    sum

}