scala的简单使用

最新推荐文章于 2024-05-30 00:38:23 发布

夏天-.-

最新推荐文章于 2024-05-30 00:38:23 发布

阅读量180

点赞数

文章标签： scala

本文链接：https://blog.csdn.net/yhquser/article/details/97406677

版权

变量的定义
在这里插入图片描述
解释：
定义变量
int和string首字母必须大写
val定义不可变对象（scala一切皆对象）
var定义可变对象
下划线为默认值
懒汉定义

解释：
懒汉定义变量（执行的时候才运行）
自动判断值类型

解释：
根据变量的值，自动的去推断数据类型
函数
在这里插入图片描述
解释：
函数的定义
函数的调用
表达式中最后一行（图中x和y）表示返回值
选择结构

循环结构

解释：
range包头不包尾
range第三个参数是步数
to包头也包尾

只有一行命令时大括号可以省略

if(flag) “aa” else “bb”

for循环结构

object ForDemo {
  def main(args: Array[String]): Unit = {
    val arr = 1 to 10
    for (item <- arr){
      print(s"值：$item")
    }
    println()
    println("——————靓丽的分割线——————")
    for (item <- arr if item%2 == 0){
      print(s"值:$item")
    }
    println()
    println("——————靓丽的分割线——————")
    for (item <- arr if item%2 == 0)print(s"值:$item")
    println()
    println("——————靓丽的分割线——————")
   for (i <- 1 to 9){
     for (j <- 1 to 9){
       if (j==1) println()
       print(s"${i * j}  ")
     }
   }
    println()
    println("——————靓丽的分割线——————")
    for {
      i <- 1 to 9
      j <- 1 to 9
    }{
      if (j == 1)println()
      print(s"${i*j}  ")
    }
    println()
    println("——————靓丽的分割线——————")
    val names = Array(" www.baidu.com ","www.google.com"," hadoop.apche.org"," ")
    for {
      name <- names
      tmpName = name.trim
      if tmpName.length>0
    }{
      println(tmpName)
    }
    println()
    println("——————靓丽的分割线——————")
    val result = for (item <- arr) yield {
      item *item
    }
    println(result)
  }
}

while循环结构

object WhileDemo {
  def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array(11,222,33,44,55,66)
    var index = 0
    while (index<arr.length){
      println(s"index=$index,value=${arr(index)}")
      index += 1
    }
  }
}

函数的使用

object FunDemo {
  //定义函数：比较2个数的较大值
  def max(x:Int,y:Int):Int = {
    if(x >y){
      x
    }else{
      y
    }
  }
  //如果一个函数的函数体只有一行代码，可以省略{}
  def max1(x:Int,y:Int):Int = if(x >y) x else y
  //如果一个函数的返回值类型，可以通过 函数体 推断得到，可以省略 返回值类型
  def max2 (x:Int,y:Int) = if(x>y) x else y
  //可以将一个函数 赋值给一个变量(注意语法)
  val max3 = max2 _
  //如果一个函数没有返回（使用Unit表示），可以省略 返回值类型 和=
  def printArray(arr:Array[Int]):Unit={
    for (item <- arr) println(item)
  }
  def printArray1(arr:Array[Int])=for (item<-arr)println(item)
  def printArray2(arr:Array[Int]) {
    for (item<-arr)println(item)
  }
  //定义函数的时候，可以给函数参数赋值，称为参数的默认值
  //注意点：有默认的参数，参数必须放在最后面
  def sayHello(name:String,msg:String="狗比"): Unit ={
    println(msg+name)
  }
  //在调用函数的时候，可以指定参数名称
  //传递参数的顺序可以和函数声明的顺序不一致（了解）
  def sayHello1(name:String,msg:String): Unit ={
    println(msg+name)
  }
  //局部函数：函数内定义函数，被外部函数调用
  def f1()={
    println("f1()")
    //定义内部函数
    def g()={
      println("g()")
    }
    //调用内部函数
    g()
  }
  //参数可变的函数
  def printCourse(course:String*)={
    course.foreach(item => println(item))
  }



  def main(args: Array[String]): Unit = {
    println(max3(1,2))
    printArray2(Array(1,2,3,4,5,6,7,8))
    sayHello( "老李","早上好")
    sayHello1(msg = "早上好",name="老李")
    f1
    f1()
    printCourse("90","80","11")
    val courseXXX = Array("11","22","33")
    printCourse(courseXXX:_*) //:_*将数组里面的元素 铺开
    val nums = Array(1,2,3,4,5,6,7,8,9)
    //foreach方法：
    //     参数名称：f
    //     参数类型：A => U
    //def foreach(f: A => U): Unit
    nums.foreach((item)=>{
      println(item)
    })

    //def println(x: Any) = Console.println(x)
    nums.foreach(println)

    //def map[B, That](f: A => B)
    val  result = nums.map( (item)=>{
      item * item
    }  )
  }
}

高阶函数

object FunDemo1 {
  //定义了一个高级函数
  def greeting(name:String,sayHello:(String)=>Unit):Unit={
    sayHello(name)//调用传递过来的函数
  }

  def main(args: Array[String]): Unit = {
    greeting("zs",(name:String)=>{
      println(name+"哦嗨油")
    })
    greeting("小姐姐",(name:String)=>{
      println(name+"奥哈要搞砸姨妈死")
    })
    greeting("刘总",(name:String)=>{
      println(name+"早")
    })
  }

Array数组

import scala.collection.mutable.ArrayBuffer

object ArrayDemo {
  def main(args: Array[String]): Unit = {
    //创建不可变数组，赋值
    var arr = Array(1,2,3,4,5)

    //获取数组中元素：使用下标，从0开始
    println(s"firet element:${arr(0)}")
    println(s"lenght:${arr.length}")
    println(s"size:${arr.size}")

    //修改数组的值
    arr(0) = 55

    //循环数组元素
    for (item <- arr) println(item)

    //只是创建数组，不赋值
    var arr2 = new Array[Int](5)//数组长度是5，数据类型int

    //可变数组：类似于Java中List
    val buffer = new ArrayBuffer[Int]()

    //添加元素
    buffer += 11
    buffer.+=(22)
    println("_____________")
    for (item <- buffer) println(item)
    //修改
    buffer(0) = 111

    //可变数组 转成 不可变数组
    var arr3: Array[Int] = buffer.toArray
    println("___________________")
    arr3.foreach(println)

    //将数组转成字符串
    println(arr3.mkString(","))
    println(arr3.mkString("<",",",">"))

    //Scala数组可以存储各种类型
    val arr4 = Array(10,99.88,"laowang")
    val first = arr4(0)
    //数据类型转换：父类 转成 子类 ，强制类型转换
    val intValue = first.asInstanceOf[Int]
    println(intValue)
  }
}

List

object ListDemo {
  def main(args: Array[String]): Unit = {
    //创建一个List，不可变的集合
    val list = List(1,2,3,4,5)

    //list组成：头+尾
    println(s"head:${list.head}")//一个元素
    println(s"tail:${list.tail}")//是一个list

    //当List只有一个元素的时候，head为元素，tail是一个空的集合
    val list2 = List(1)
    println(s"head${list2.head}")
    println(s"tail${list2.tail}")

    //list创建方式二：
    val list3 = 1::Nil   //Nil.::(1), ::从右往左运算
    val list4 = 1::2::3::Nil  //头插法
    println(list4)//List(1, 2, 3)

    //可变的集合
    import scala.collection.mutable.ListBuffer

    //创建可变的list
    val listBuffer = ListBuffer[Int]()
    //添加元素
    listBuffer += 1
    listBuffer += 2
    listBuffer += 3
    listBuffer ++= List(4,5,6)
    listBuffer += (7,8,9)

    //可变的List转成不可变
    val list5 = listBuffer.toList
    println(list5.mkString(","))//1,2,3,4,5,6,7,8,9

    //判定List是否为空
    println(list5.isEmpty)

    //判定list是否存在某个元素
    println(list5.contains(9))
  }
}

List方法

object ListFunDemo {
  def main(args: Array[String]): Unit = {
    //创建一个List，不可变的集合
    val list = (1 to 10).toList
    // def map[B](f: A => B): TraversableOnce[B]
    //map - >  f:(A) => B
    // A：集合List中数据类型、

    val mapList = list.map((item)=>{
      item*item
    })
    val mapList1 = list.map(item=>item*item)
    //println(mapList1.mkString(","))

    //分割单词
    val lineList = List(
      "hadoop hive spark hadoop java",
      "spark java sqool hive",
      "hadoop hive spark java"
    )
    //String -> Array(Iterable)
    val xx: List[Array[String]] = lineList.map(line=>line.split(" "))

    //flatMap压平函数
    val flatMap: List[String] = lineList.flatMap(line=>line.split(" "))
    //println(flatMap.mkString(","))

    //过滤
    val filterList = list.filter(item=>item%2==0)//为true留下
    val filterList1 = list.filter(_ %2==0)//为true留下
    //println(filterList1.mkString(","))

    list.filterNot(item=>item%2==0)//
    val fileterNOt1: List[Int] = list.filterNot(_ %2==0)//
    //println(fileterNOt1.mkString(","))

    //分组
    // def groupBy[K](f: A => K)
    //A:List中元素，K：分组类别
    val groupKey = list.groupBy(item=>item%3)
    //groupKey.foreach(println)

    //排序
    /**
      * sorted
      *  默认情况下，依据集合中List的元素，自然排序规则：升序
      * sortBy
      *   指定元素的排序规则（升序，还是降序）
      */
    val list2 = List(11,8,12,88,33,55,77,24,46,34)
    //println(list2.sorted.mkString(","))//8,11,12,24,33,34,46,55,77,88
    //println(list2.sortBy(item => -item))List(88, 77, 55, 46, 34, 33, 24, 12, 11, 8)
    //println(list2.sortWith((x1,x2)=>x1>x2).mkString(","))//88,77,55,46,34,33,24,12,11,8
    //println(list2.sortWith((x1,x2)=>x1<x2).mkString(","))//8,11,12,24,33,34,46,55,77,88
    //println(list2.sortWith(_ < _).mkString(","))//8,11,12,24,33,34,46,55,77,88

    //reduce  ->   op: (A1, A1) => A1
    //第一个参数A1: 可以理解为 聚合时  临时变量 ，初始值 集合head的值
    //第二个参数A2:每个元素的值
    val reduce = list.reduce((x1,x2)=>{
      println(s"x1=$x1,x2=$x2")
      x1 + x2
    })
    println(reduce)
  }
}