Scala简单学习

最新推荐文章于 2023-07-06 08:15:00 发布
最新推荐文章于 2023-07-06 08:15:00 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： Hadoop 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xixihaha_coder/article/details/124021741
版权

文章目录

Scala简单学习

Helloworld演示

/**
 * object 关键字 声明一个单例对象（伴生对象）
 * def 方法名称（参数名称： 参数类型）： 返回值类型={ 方法体 }
 */
object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("123")
  }
}

注释

scala注释和java完全一样

ctrl + alt +l 来进行格式化

变量 常量

package com.tian.demo01

/*
var 变量名[: 变量类型]   var i:Int =10   可以简写 var i=10
val 常量名[: 变量类型]   val j:Int =20   可以简写 val j=10

注意 : 能用常量的地方不用变量
 */

object Study02 {
  def main(args: Array[String]): Unit = {
    var a:Int =10

    var a1=10  //自动推断类型为 Int
    val b1=23

   // a1='10'; //报错 类型确定后就不能修改

    //变量声明时，必须要有初始值
    //var a3   //报错

    a1=25
    //b1=32  报错 b1 是常量
      
      
      //对象中的属性可以修改 student.age=24
      //对象不能更改var student = new Student()
  }
}

标识符

以字母或下划线开头

以操作符开头 且只包括 ±/* ！

以`` 包括的任何字符串

字符串

object Study03 {
  def main(args: Array[String]): Unit = {
    // 通过 +号连接
    val name:String="zhangsan"
    val age:Int=18
    println(age+"岁的"+name)

    println(name * 3) //zhangsanzhangsanzhangsan

    //printf用法 通过%传值
    printf("%d岁的%s\n",age,name)

    // 字符串模板 通过$获取变量值
    println(s"${age}岁的${name}")

    val num=2.3458
    println(f"this num is ${num}%2.2f") //2.35 格式化模板字符串
    
    //三引号 保持多行 （sql语句）
   val sql= s"""
       |*****
       |*****
       |*****
       |""".stripMargin
    
  }
}

键盘输入

import scala.io.StdIn

object Study04 {
  def main(args: Array[String]): Unit = {
    //输入信息
    println("请输入你的大名:")
    val name=StdIn.readLine()
    println("请输入你的年龄:")
    val age=StdIn.readInt()
    println(s"欢迎${name},年龄${age}")
  }
}

文件的操作

import scala.io.Source

object Study05 {
  def main(args: Array[String]): Unit = {
    //从文件中读取数据
    Source.fromFile("C:\\Users\\86159\\Desktop\\Blog\\scala\\aa.txt").foreach(print)

    //将数据写入文件
    val writer=new PrintWriter(new File("C:\\Users\\86159\\Desktop\\Blog\\scala\\aa.txt"))
    writer.write("你好")
    writer.close()
  }
}

数据类型

在这里插入图片描述

字符类型

object Study06 {
  def main(args: Array[String]): Unit = {
    val c3:Char = '\t'
    val c4:Char = '\n'   //换行符
    println("abc"+c3+"efg") // abc	efg
    println("abc"+c4+"efg")

    val c5='\\'    //相当于 \
    val c6='\"'    //相当于"
    println("abc"+c5+"efg") // abc\efg
    println("abc"+c6+"efg") // abc"efg
  }
}

Unit类型 Null类型 Nothing类型

在这里插入图片描述

object Study07 {
  def main(args: Array[String]): Unit = {


    def m1():Unit={
      println("m1被调用了")
    }
    val a:Unit=m1()
    println("a: " + a)    //m1被调用了
                          // a: ()

    //空引用Null
    //var student :Student =new Student("zhangsan",13)
    //student=null
    //println(student) // null


    // Nothing
    def m2(n:Int) : Int={
      if(n==0){
        throw new NullPointerException
      }else{
        return n
      }
    }
    val b:Int =m2(2)
    println("b: " + b)  // b: 2

  }
}

类型转换

object Study08 {
  def main(args: Array[String]): Unit = {
    val a1:Byte =10;
    val b1:Long =3532;
    val result1:Int =(a1+b1).toInt   //强转

    
    //(byte short) 和char 之间不会相互自动转换
    // byte short char 他们三者可以计算 ，但在计算前先转换为int类型
      
    //数值转String
    val n=12
    val s:String=n+""
    println(s)
    //String转数值
    val m:Int="12".toInt
    val f:Float="12.3".toFloat
    val f2:Int="12.3".toDouble.toInt
  }
}

算数运算符

val result2:Double=10/3  //3.0
println(result2)
val result3:Double=10.0/3
println(result3.formatted("%5.2f")) //  3.33

比较运算符

object Study09 {
  def main(args: Array[String]): Unit = {

    val s1="hello"
    val s2=new String("hello")
    println(s1 == s2)  //true
    println(s1.equals(s2)) //true
    println(s1.eq(s2)) //false
  }
}

scala没有++ --操作符

特殊语法

val n1:Int =12
val n2:Int =37
println(n1.+(n2)) //49  
println(n1 toString)  // 可以省略点 直接用空格

流程控制

简写

val res = if(age >= 18) "成年" else "未成年"

FOR遍历

object Study01 {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10){
      println("helloworld")
    } //输出10次
    //相当于
    for (i <- 1.to(10)){
      println("helloworld1")
    }  //输出10次
      
    for(i <- Range(1,10)){
      println("helloworld2"+i)
    }  //输出9次   1-9 
      
      for (i <- 1 until  10){
          println("helloworld"+i)
      } //输出9次   1-9 
  }
}

集合遍历

object Study02 {
  def main(args: Array[String]): Unit = {
      for(i <- Array(12,22,32)){
        println(i)
      }
    for(i <- List(12,22,32)){
      println(i)
    }
    for(i <- Set(12,22,32)){
      println(i)
    }
  }
}

循环守卫

   for (i <- 1 to 10 if i != 5){ //跳过5输出 
     println(i)
   }

循环步长 By

 for (i <- 1 to 10 by 2){
     println(i) // 1 3 5 7 9
   }


 for (i <- 30 to 20 by -2){
      println(i) //30 28 26 24 22 20
    }

 for (i <- 1 to 10 reverse){
      println(i) // 倒序
    }


//by 0 会报错

//浮点数  有精度问题
    for (i <- 1.0 to 10.0 by 0.5){
      println(i)
    }

嵌套循环

package com.tian.demo02

object Study05 {
  def main(args: Array[String]): Unit = {
//    for (i <- 1 to 3) {
//      for (j <- 1 to 3) {
//        println("i = " + i + ",j = " + j)
//      }
//    }

//    for (i <- 1 to 3 ;j <- 1 to 3 ){
//      println("i = " + i + ",j = " + j)
//    }


    //九九乘法表
    for (i <- 1 to 9 ;j <- 1 to i ){
      print(i +"*"+ j +"=" + i*j+"\t" )
     if(j==i) println()
    }
  }
}

引入变量

package com.tian.demo02

object Study06 {
  def main(args: Array[String]): Unit = {
//    for (i <- 1 to 10) {
//      val j = 10 - i
//      println("i=" + i + ",j=" + j)
//    }
    //相当于
    for (i <- 1 to 10;j = 10 - i) {

      println("i=" + i + ",j=" + j)
    }
    /*
        i=1,j=9
        i=2,j=8
        i=3,j=7
        i=4,j=6
        i=5,j=5
        i=6,j=4
        i=7,j=3
        i=8,j=2
        i=9,j=1
        i=10,j=0
    */

      //还可以这么写
   for {
      i <- 1 to 10
      j = 10 - i
    } {
      println("i=" + i + ",j=" + j)
    }
  }
}

打印输出九层妖塔

package com.tian.demo02

object Study07 {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9) {
      val stars = 2 * i - 1
      val space = 9 - i
      println(" " * space + "*" * stars)
    }

  //第二种
    for (i <- 1 to 9;stars = 2 * i - 1;space = 9 - i) {
      println(" " * space + "*" * stars)
    }
  }
}

循环返回值

if else 也有返回值

package com.tian.demo02

object Study08 {
  def main(args: Array[String]): Unit = {
    val unit:Unit = for (i <- 1 to 10) {
      println(i)
    }
    println("返回值:"+unit)  //  返回值:()

    val ints = for (i <- 1 to 10) yield i
    println("返回值:"+ints) //返回值:Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val ints1 = for (i <- 1 to 10) yield i * 2
    println(ints1) // Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
  }
}

while不推荐使用 推荐使用for循环

循环中断

在这里插入图片描述

package com.tian.demo02

import scala.util.control.Breaks

object Study09 {
  def main(args: Array[String]): Unit = {
    //1.采用抛出异常的方式 退出循环
    try {
      for (i <- 1 to 10) {
        if (i == 3) {
          throw new RuntimeException
        }
        println(i)
      }
    } catch {
      case e: Exception => //什么都不做只是退出循环
    }

    //2. 使用scala中的Breaks类的break方法，实现异常的抛出和捕捉
    Breaks.breakable(
      for (i <- 1 to 10) {
        if (i == 3) {
          Breaks.break()
        }
        println(i)
      }
    )
    println("这是循环外的代码")
  }
}

函数式编程

集合

不可变数组

package com.tian.demo03

object Study01 {
  def main(args: Array[String]): Unit = {
    //数组定义
    val arr01: Array[Int] = new Array[Int](4)
    println(arr01.length) // 4
    //另一种创建方式
    val arr2 = Array.apply(12, 2, 3, 23, 45)
    println(arr2.length) // 5

    //访问元素
    println(arr01(0)) //0
    println(arr01(1)) //0
    println(arr2(0)) //12
    println(arr2(1)) //2
    arr2(0) = 22 // 直接改值
//    arr2.update(2,100)  //改值
    println(arr2(0)) //22

    //遍历 第一种
    for (i <- 0 until arr01.length) {
      println(arr01(i))
    }
    //遍历 第二种
    for (i <- arr2.indices) {
      println(arr2(i))
    }
    println("-------------------")
    //遍历 第三种
    for (elem <- arr2) {
      println(elem)
    }
    println("-------------------")
    //遍历 第四种
    val iter=arr2.iterator
    while(iter.hasNext){
      println(iter.next())
    }
    println("=================")
    //遍历 第五种
    arr2.foreach((elem:Int) => println(elem))
    //遍历 第六种
    arr01.foreach(println)
    println(arr2.mkString("--")) // 22--2--3--23--45
  }
}

添加元素

package com.tian.demo03

object Study02 {
  def main(args: Array[String]): Unit = {
    val arr1: Array[Int] = new Array[Int](4)

    val arr2 = Array.apply(12, 2, 3, 23, 45)

    //添加元素
    arr2.:+(73)
    println(arr2.mkString("--"))  //12--2--3--23--45

    val newArr=arr2.:+(73) //在后面加  冒号前后面加
    println(newArr.mkString("--"))  //12--2--3--23--45--73

    val newArr2=arr2.+:(1)  //在前面加
    println(newArr2.mkString("--"))  //1--12--2--3--23--45

    
  }
}

可变数组

package com.tian.demo03

import scala.collection.mutable.ArrayBuffer

object Study03 {
  def main(args: Array[String]): Unit = {
    //创建一个可变数组
    val arr1:ArrayBuffer[Int] = new ArrayBuffer[Int]()
    val arr2=ArrayBuffer(23,57,92)

    println(arr1) // ArrayBuffer()
    println(arr2) //ArrayBuffer(23, 57, 92)

    //访问元素
    println(arr2(0)) //23
    arr2(0)=33 //修改
    println(arr2(0)) //33

    //遍历访问
    for (i <- arr2.indices) {
      println(arr2(i))
    }

    println("---------------")
    arr1 :+ 15   //不适用可变数组  不适用赋值给新的数组
    println(arr1) // ArrayBuffer()


    arr1 += 19  // 添加元素 往后加
    println(arr1) // ArrayBuffer(19)

    20 +=: arr1  // 往前加
    println(arr1) //ArrayBuffer(20, 19)

    //推荐
    arr1.append(44)
    arr1.prepend(33)
    println(arr1) // ArrayBuffer(33, 20, 19, 44)
    arr1.insert(1,100)
    println(arr1) // ArrayBuffer(33, 100, 20, 19, 44)

   // arr1.insertAll(位置，数组) 添加数组
    // arr1.prependAll(位置，数组) 往前

    //删除
    arr1.remove(1)
    println(arr1) // ArrayBuffer(33, 20, 19, 44)

    arr1.remove(0,2)
    println(arr1) // ArrayBuffer(19, 44)

    arr1 -= 44 //删掉一个44
    println(arr1) // ArrayBuffer(19)
  }
}

可变、不可变数组转换

import scala.collection.mutable.ArrayBuffer

object Study04 {
  def main(args: Array[String]): Unit = {
    //可变 ==》 不可变
    val  arr =ArrayBuffer(23,56,98)
    val newArr=arr.toArray
    println(newArr.mkString(",")) //23,56,98
    println(arr) // ArrayBuffer(23, 56, 98)

    val buffer = newArr.toBuffer
    println(buffer) //ArrayBuffer(23, 56, 98)
    println(newArr) // [I@5b464ce8
  }
}

二维数组

object Study05 {
  def main(args: Array[String]): Unit = {
    //创建二维数组
    val array = Array.ofDim[Int](2, 3)
    //访问元素
    array(0)(2) = 19
    array(1)(0) = 25
    for (i <- 0 until array.length; j <- 0 until array(i).length) {
      print(array(i)(j) + "\t")
      if (j == array(i).length - 1) println()
    }
    //0	  0	 19
    //25  0	 0
  }
}

列表

package com.tian.demo03

object Study06 {
  def main(args: Array[String]): Unit = {
    // 创建一个List
    val list = List(23, 65, 87)
    println(list) //List(23, 65, 87)
    println(list(1)) // 65

    // list(1)=12 不能更改 报错
    //遍历
    list.foreach(println) //23 65 87

    //添加元素
    println("=======================")
    val list2 = list.+:(10)
    println(list2) //List(10, 23, 65, 87)

    println("------------")
    val list3=list2.::(1) //很少用
    println(list3) // List(1, 10, 23, 65, 87)

    println("------------")
    val list4=Nil.::(11)
    println(list4) // List(11)

    val list5=17 :: 28 :: 32 :: 99 :: Nil
    println(list5) // List(17, 28, 32, 99)
    println("=======================")

    val list6 = list5 ::: list4   //两个数组元素全部添加
//    val list6 = list5 ++ list4   ++ 相当于 :::
    println(list6) // List(17, 28, 32, 99, 11)
  }
}

不可变列表

package com.tian.demo03

import scala.collection.mutable.ListBuffer

object Study07 {
  def main(args: Array[String]): Unit = {
    //创建可变列表
    val ints = new ListBuffer[Int]()
    val ints1 = ListBuffer(12, 53, 785)
    println(ints)  // ListBuffer()
    println(ints1) //ListBuffer(12, 53, 785)

    //添加元素
    ints.append(15,65,66)
    ints1.append(232)
    println(ints) // ListBuffer(15, 65, 66)
    println(ints1) //ListBuffer(12, 53, 785, 232)
    ints.prepend(22)
    ints1.insert(1,100)
    println(ints) //ListBuffer(22, 15, 65, 66)
    println(ints1) //ListBuffer(12, 100, 53, 785, 232)

    ints1(4)=200
    println(ints1) //ListBuffer(12, 100, 53, 785, 200)

    ints1.remove(2) //下标删除
    println(ints1) // ListBuffer(12, 100, 785, 200)

  }
}

Set集合

无序不重复

不可变集合

package com.tian.demo03

object Study08 {
  def main(args: Array[String]): Unit = {
    //创建不可变集合
    val set = Set(11, 22, 88, 99, 77, 88, 99)
    println(set) // Set(88, 77, 22, 11, 99)

    println("============")
    //添加元素
    //    val set1 = set.+(20)
    val set1 = set + 20 //同上一样
    println(set1) // Set(88, 20, 77, 22, 11, 99)

    println("============")
    //合并set
    val set3 = Set(1, 2, 3, 4)
    val set4 = Set(77, 88, 99, 1)
    val set5 = set3 ++ set4
    println(set5) // Set(88, 1, 77, 2, 3, 99, 4)

    //删除元素
    val set6 =set4 - 88
    println(set6) // Set(77, 99, 1)
  }
}

可变集合

package com.tian.demo03

import scala.collection.mutable

object Study09 {
  def main(args: Array[String]): Unit = {
    //创建可变
    val set = mutable.Set(11, 22, 88, 99, 77, 88, 99)
    println(set) // Set(88, 77, 22, 11, 99)
    println("=============")
    //添加元素
    val set2 = set + 500
    println(set2) // Set(99, 88, 500, 22, 11, 77)

    set += 200
    println(set) // Set(99, 88, 22, 11, 77, 200)

    set.add(100) //推荐使用
    println(set) // Set(99, 88, 100, 22, 11, 77, 200)
    println("=============")
    //删除元素
    set -= 100
    println(set) // Set(99, 88, 22, 11, 77, 200)

    set.remove(200)
    println(set) //Set(99, 88, 22, 11, 77)
    println("=============")
    //合并两个Set
    val set3 = mutable.Set( 1000)
    val set4 = set3 ++ set
    println(set) // Set(99, 88, 22, 11, 77)
    println(set3) // Set(1000)
    println(set4) // Set(99, 88, 1000, 22, 11, 77)
    println("=============")
    set ++= set3
    println(set3) // Set(1000)
    println(set) // Set(99, 88, 1000, 22, 11, 77)
  }
}

Map集合

不可变Map

package com.tian.demo03

object Study10 {
  def main(args: Array[String]): Unit = {
    //创建不可变map
    val map1: Map[String, Int] = Map("a" -> 13, "b" -> 25)
    println(map1) // Map(a -> 13, b -> 25)
    println("----------")
    //遍历元素
    map1.foreach(println)
    //(a,13)
    //(b,25)
    println("----------")
    //取map中所有的key 或者value
    for(key <- map1.keys){
      println(s"$key ---> ${map1.get(key)}")
      //a ---> Some(13)
      //b ---> Some(25)
    }
    println("----------")
    //访问某一个key的value
    println(map1.get("a").get) // 13
    println(map1.getOrElse("c",0)) //0  没有c 返回0   推荐使用
  //简写
    println(map1("a"))  // 13
  }
}

可变Map

package com.tian.demo03

import scala.collection.mutable

object Study11 {
  def main(args: Array[String]): Unit = {
    //创建可变map
    val map1: mutable.Map[String, Int] = mutable.Map("a" -> 13, "b" -> 25)
    println(map1) // Map(a -> 13, b -> 25)
    println("------------")
    //添加元素
    map1.put("C",5)
    map1.put("d",9)
    println(map1) //Map(b -> 25, d -> 9, C -> 5, a -> 13)
    println("------------")
    //删除元素
    map1.remove("a")
    println(map1)
    println("------------")
    //修改元素 有就更改 没有就添加
    map1.update("a",100)
    println(map1)

  }
}

元组

package com.tian.demo04

object Study01 {
  def main(args: Array[String]): Unit = {
    // 创建元组(1-22)
    val tuple:(String,Int,Boolean,Char)=("hello",45,true,'a')
    println(tuple) //(hello,45,true,a)
    //访问元素
    println(tuple._1) //hello
    println(tuple._2) // 45
    println(tuple._3) // true
    println(tuple._4) // a
    println("------------------")
    //遍历元组
    for(elem <- tuple.productIterator){
      println(elem)
    }

    //嵌套元组
    val tup1=(12,0.3,"hello",(23,"scala"))
    println(tup1._4._2) //scala
  }
}

集合常用操作

package com.tian.demo04

object Study02 {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4, 5, 6)
    val set = Set(22, 33, 44, 55)
    println(list.length) //6
    println(set.size) //4

    //循环遍历
    for (elem <- list) {
      println(elem)
    }
    set.foreach(println)
  //迭代器
    for (elem <- list.iterator) println(elem)

    //生成字符串
    println(list)
    println(set)
    println(list.mkString("--"))

    //是否包含
    println(list.contains(5)) //true

  }
}

衍生集合

package com.tian.demo04

object Study03 {
  def main(args: Array[String]): Unit = {
    val list1 = List(1, 2, 3, 4, 5)
    val list2 = List(5, 6, 7, 8, 9)
    //获取头
    println(list1.head) //1
    //获取尾
    println(list1.tail) // List(2, 3, 4, 5)  不是头 都是尾

    //集合最后一个数据
    println(list2.last) //9

    //集合初始数据（不包含最后一个）
    println(list2.init) //List(5, 6, 7, 8)

    //反转
    println(list2.reverse) // List(9, 8, 7, 6, 5)

    //取前n(后)个元素
    println(list1.take(3)) //List(1, 2, 3)
    println(list1.takeRight(4)) //List(2, 3, 4, 5)

    //去掉前(后)n个元素
    println(list2.drop(3)) //List(8, 9)
    println(list2.dropRight(3)) //List(5, 6)

    //并集
    val union = list1.union(list2)
    println(union) //List(1, 2, 3, 4, 5, 5, 6, 7, 8, 9)
    println(list1 ::: list2) //List(1, 2, 3, 4, 5, 5, 6, 7, 8, 9)
    //set会去重

    //交集
    val inter = list1.intersect(list2)
    println(inter) //List(5)

    //差集
    val diff1 = list1.diff(list2)
    val diff2 = list2.diff(list1)
    println(diff1) //List(1, 2, 3, 4)
    println(diff2) //List(6, 7, 8, 9)

    //拉链
    println(list1.zip(list2)) //List((1,5), (2,6), (3,7), (4,8), (5,9))
    println(list2.zip(list1)) // List((5,1), (6,2), (7,3), (8,4), (9,5))

    //滑窗
    for (elem <- list1.sliding(3)) {
      println(elem)
    }
    //List(1, 2, 3)
    //List(2, 3, 4)
    //List(3, 4, 5)
  }
}

集合计算简单函数

package com.tian.demo04

object Study04 {
  def main(args: Array[String]): Unit = {
    val list1 = List(1, 2, 3, 4, 5)
    val list2 = List(5, 6, 7, 8, 9)
    val list3=List(("a",10),("b",55),("f",1))
    //求和
    var sum = 0
    for (elem <- list1) {
      sum += elem
    }
    println(sum)  // 15
    println(list2.sum) //35
    println(list1.product) // 乘积 120
    println(list1.max) //最大值 5
    println(list1.min) //最小值 1
    println(list3.max) //(f,1)  看第一个
    println(list3.maxBy(((tuple:(String,Int))=>tuple._2)))  //(b,55)
   //简写
    println(list3.maxBy(_._2)) //(b,55)
    println(list3.minBy(_._2)) // (f,1)

    //排序
    val sortList=list1.sorted  //从小到大
    println(sortList)

    //从大到小
    println(list1.sorted.reverse) //List(5, 4, 3, 2, 1)
    println(list1.sorted(Ordering[Int].reverse)) //List(5, 4, 3, 2, 1)

    //按第二个数字大小排序
    println(list3.sortBy(_._2)) //List((f,1), (a,10), (b,55))
    println(list3.sortBy(_._2)(Ordering[Int].reverse)) //List((b,55), (a,10), (f,1))


    println(list1.sortWith((a:Int,b:Int)=>{a<b})) //List(1, 2, 3, 4, 5)
    println(list1.sortWith((a:Int,b:Int)=>{a>b})) // List(5, 4, 3, 2, 1)
    //简写
    println(list1.sortWith(_ < _)) //从小到大
    println(list1.sortWith(_ > _)) //从大到小
  }
}

集合计算高级函数

package com.tian.demo04

object Study05 {
  def main(args: Array[String]): Unit = {
    val list1 = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //选取偶数
    println(list1.filter(elem => elem % 2 == 0)) //List(2, 4, 6, 8)
    //选取奇数
    println(list1.filter(_ % 2 == 1)) //List(1, 3, 5, 7, 9)

    //把集合中每个数乘以2
    println(list1.map(_ * 2)) //List(2, 4, 6, 8, 10, 12, 14, 16, 18)
    println(list1.map(x => x * x)) //每个数平方

    //扁平化
    val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
    val flatList = nestedList.flatten
    println(flatList) // List(1, 2, 3, 4, 5, 6, 7, 8, 9)

    //扁平映射
    //将一组字符串进行分词，并保存成单词的列表
    val strings: List[String] = List("hello world", "hello scala")
    val splitList = strings.map(_.split(" "))
    val flatten = splitList.flatten
    println(flatten) //List(hello, world, hello, scala)

    //group by
    //分成奇偶两组
    val groupMap = list1.groupBy(_ % 2)
    val groupMap2 = list1.groupBy(data => if (data % 2 == 0) "偶数" else "奇数")
    println(groupMap) //Map(1 -> List(1, 3, 5, 7, 9), 0 -> List(2, 4, 6, 8))
    println(groupMap2) //Map(奇数 -> List(1, 3, 5, 7, 9), 偶数 -> List(2, 4, 6, 8))

    //给定一组词汇，按首字母排序
    val worldList = List("china", "cccc", "aaa", "abb", "bb")
    println(worldList.groupBy(_.charAt(0))) //Map(b -> List(bb), a -> List(aaa, abb), c -> List(china, cccc))
  }
}

reduce

package com.tian.demo04

object Study06 {
  def main(args: Array[String]): Unit = {
    val list1 = List(1, 2, 3, 4)
    println(list1.reduce(_ + _)) // 10

    println(list1.reduceLeft(_ + _)) //10
    println(list1.reduceRight(_ + _)) //10

    val list2 = List(3, 4, 5, 8, 10)
    println(list2.reduce(_ - _)) // -24
    println(list2.reduceLeft(_ - _)) //-24
    println(list2.reduceRight(_ - _)) // 6  3-(4-(5-(8-10)))
  }
}

fold

package com.tian.demo04

object Study06 {
    def main(args: Array[String]): Unit = {
        val list1 = List(1, 2, 3, 4)
        val list2 = List(3, 4, 5, 8, 10)

        println(list1.fold(10)(_ + _)) //20  10+1+2+3+4
        println(list1.foldLeft(10)(_ - _)) // 0   10 - 1 - 2 - 3 - 4
        println(list2.foldRight(11)(_ - _))  // -5  3-(4-(5-(8-(10-11))))

    }
}

wordCount案例

package com.tian.demo04

object Study07 {
    def main(args: Array[String]): Unit = {


        val lineList = List(
            "hadoop hive spark hadoop java",
            "spark java sqool hive",
            "hadoop hive spark java"
        )

        //压平函数
        var faltSplit: List[String] = lineList.flatMap(item=>item.split(" "))
        //把每个单词生成一个一个的tuple
        var first= faltSplit.map(item=>(item,1))
        //一key进行分组
        var second = first.groupBy(item=>item._1)
        //统计value的长度
        var third = second.mapValues(_.size)
        //排序
        val fifth = third.toList.sortBy(_._1)
        println(first)
        println(second)
        println(third)
        println(fifth)
        //List((hadoop,1), (hive,1), (spark,1), (hadoop,1), (java,1), (spark,1), (java,1), (sqool,1), (hive,1), (hadoop,1), (hive,1), (spark,1), (java,1))
        //Map(java -> List((java,1), (java,1), (java,1)), hadoop -> List((hadoop,1), (hadoop,1), (hadoop,1)), sqool -> List((sqool,1)), spark -> List((spark,1), (spark,1), (spark,1)), hive -> List((hive,1), (hive,1), (hive,1)))
        //Map(java -> 3, hadoop -> 3, sqool -> 1, spark -> 3, hive -> 3)
        //List((hadoop,3), (hive,3), (java,3), (spark,3), (sqool,1))
    }
}

队列

package com.tian.demo04

import scala.collection.immutable.Queue
import scala.collection.mutable

object Study08 {
  def main(args: Array[String]): Unit = {
    //创建一个可变队列
    val queue = new mutable.Queue[String]()
    queue.enqueue("a", "b", "c")
    println(queue) //Queue(a, b, c)
    println(queue.dequeue()) // a
    println(queue.dequeue()) // b

    //不可变队列
    val queue2 = Queue("a", "b", "c")
    println(queue2) //Queue(a, b, c)
    //出队入队要赋值给新队列
    val queue3= queue2.enqueue("d")
    println(queue3)
  }
}

函数式编程

函数基本语法

在这里插入图片描述

object Study01 {
  def main(args: Array[String]): Unit = {
    def f(args:String):Unit={
      println(args) //你好
    }
    f("你好")
    Study01.f("你好2")
    val result= Study01.f("你好2")
    println(result) //hello
  }

  def f(args:String):String={
    println("下面的"+args) //你好2
    return "hello"
  }
}

函数参数

package com.tian.demo05

object Study02 {
  def main(args: Array[String]): Unit = {
    //可变参数
    def f1(str:String*):Unit={
      println(str)
    }
    f1("aaa","bbb","ccc") //WrappedArray(aaa, bbb, ccc)

    //如果有多个参数，可变参数一般放到最后

    //参数默认值
    def f2(str:String="默认值"):Unit={
      println(str)
    }
    f2()  //默认值
    f2("新的值") //新的值
    //待命参数
    def f3(name:String="默认值",age:Int):Unit={
      println(s"${age}的${name}")
    }
    f3(age=23,name="张三") //23的张三

  }
}

函数至简原则

package com.tian.demo05

object Study03 {
    def main(args: Array[String]): Unit = {
        def f1(name:String):String={
            return name
        }
        //return 可以省略
        def f2(name:String):String={
            name
        }

        println(f2("张三"))
        //如果只有一行 花括号可以省略
        def f3(name:String):String=name
        //如果返回值类型能够推断，省略类型
        def f4(name:String) =name
        //如果声明unit，return 没作用
        def f5(name:String):Unit={
            return name
        }
        //匿名函数 lambda表达式
        (name:String) =>{println(name)}

        
        //调用
        val fun= (name:String) =>{println(name)}
        fun("张三")
    }
}

lambda表达式

package com.tian.demo05

object Study04 {
  def main(args: Array[String]): Unit = {
   val fun= (name:String) =>{println(name)}
    fun("张三")

    def f(func:String=>Unit):Unit={
      func("atguigu")
    }
    f(fun)
    f((name:String) =>{println(name)})

    //简化
    f(name =>{println(name)})
    f(println(_))
    f(println)


  }
}

再理接匿名函数

object Study05 {
    def main(args: Array[String]): Unit = {
        def Two(fun:(Int,Int)=>Int):Int={
            fun(1,2)
        }
        val add=(a:Int,b:Int)=>a+b
        val minus=(a:Int,b:Int)=>a-b

        println(Two(add)) //3
        println(Two(minus)) //-1
		//简写
        println(Two(_+_)) //3
        println(Two(_-_)) //-1
    }
}


object Study06 {
  def main(args: Array[String]): Unit = {
    def f1(n:Int):Int={
      println("被调用了")
      n+1
    }
    //函数作为值进行传递
    val f2:Int=>Int =f1
    val f3=f1 _
    println(f2(200)) 
    //被调用了
    //201
    println(f3(100))
    //被调用了
    //101
      
      //函数作为函数的返回值返回
    def f5():Int=>Unit={
      def f6(a:Int):Unit={
        println("f6调用"+a)
      }
      f6
    }
    val f6=f5()
    println(f6)
    println(f6(25))
    println(f5()(25))
    //<function1>
    //f6调用25
    //()
    //f6调用25
    //()
  }
}

练习

在这里插入图片描述

object Study07 {
  def main(args: Array[String]): Unit = {
    val fun=(i:Int,s:String,c:Char)=>{
      if(i==0&&s==""&&c=='0') false else true
    }

    println(fun(0,"",'0')) //false
    println(fun(0,"",'1')) //true
    println(fun(1,"",'0')) //true
    println(fun(0,"1",'0')) //true
  }
}

在这里插入图片描述

在这里插入图片描述

简写

在这里插入图片描述

第二种 柯里化 推荐

在这里插入图片描述

闭包&柯里化

闭包

object Study08 {
  def main(args: Array[String]): Unit = {
    def addByA3(a:Int):Int=>Int =a+_
    val addByFour3=addByA3(4)
    val addByFive=addByA3(5)

    println(addByFour3(13)) //17 
    println(addByFive(25))  //30
  }
}

柯里化

 //柯里化
    def addCurring(a:Int)(b:Int):Int={
      a+b
    }
    println(addCurring(35)(24)) //59

递归

package com.tian.demo05

import scala.annotation.tailrec

object Study09 {
  def main(args: Array[String]): Unit = {
    //计算阶乘
    def fact(n: Int): Int = {
      if (n == 0) return 1
      fact(n - 1) * n
    }

    println(fact(5)) //120

    //尾递归  优化
    def tailFact(n: Int): Int = {
      @tailrec
      def loop(n: Int, res: Int): Int = {
        if (n == 0) return res
        loop(n - 1, res * n)
      }
      loop(n,1)
    }

    println(tailFact(5)) //120
  }
}

控制抽象

package com.tian.demo05

object Study10 {
  def main(args: Array[String]): Unit = {
    def f0(): Int = {
      println("f1调用")
      12
    }

    //传名参数,传递的不再是具体的值，而是代码块
    def f1(a: => Int): Unit = {
      println("a: " + a)
      println("a: " + a)
    }

    f1(12) 
    //a: 12
    //a: 12
    f1(f0())//a调用几次 f1就调用几次
    //f1调用
    //a: 12
    //f1调用
    //a: 12
  }
}

惰性加载

package com.tian.demo05

object Study11 {
  def main(args: Array[String]): Unit = {
    lazy val res: Int = sum(13, 47)
    println("1.函数调用")
    println("2.res=" + res)
    println("4.res=" + res)

    def sum(i: Int, i1: Int): Int = {
      println("3.sum调用")
      i + i1
    }

    println(res) //60
    //1.函数调用
    //3.sum调用
    //2.res=60
    //4.res=60
    //60
  }
}

面向对象

包对象

在这里插入图片描述

在这里插入图片描述

chapter06下的包可以调用

导包

通配符 import java.util._ 导入java.util包下的所有

在这里插入图片描述

类class和对象object

package com.tian.demo06

import scala.beans.BeanProperty

object Study01 {
  def main(args: Array[String]): Unit = {
    val student = new Student
//    student.name  私有 不能访问
    println(student.age) //18
    println(student.age1) // 0
    println(student.sex) //男
    println(student.sex1) // null
  }
}
//定义一个类
class Student{
  private var name="zhangsan"
  @BeanProperty   //相当于Lombok中的@Data
  val age=18
  var age1:Int= _  //默认值
  val sex='男'
  var sex1:String= _
}

封装

在这里插入图片描述

构造器

package com.tian.demo06

object Study02 {
  def main(args: Array[String]): Unit = {
    val student = new Student1
    student.Student1()
    println("==========")
    val student2=new Student1("alice")
    val student3=new Student1("alice",25)
    //1.主构造方法被调用
    //一般方法被调用
    //==========
    //1.主构造方法被调用
    //2.辅助构造方法一 被调用
    //name:alice age:0
    //1.主构造方法被调用
    //2.辅助构造方法一 被调用
    //name:alice age:0
    //3.辅助构造三 被调用name:alice age:25
  }
}

//定义一个类
class Student1() {
  var name: String = _
  var age: Int = _
  println("1.主构造方法被调用")

  //声明辅助构造器方法
  def this(name: String) {
    this() //直接调用主构造器
    println("2.辅助构造方法一 被调用")
    this.name = name
    println(s"name:${name} age:$age")
  }

  //声明辅助构造器方法 (可以有多个)
  def this(name: String, age: Int) {
    this(name)
    print("3.辅助构造三 被调用")
    this.age = age
    println(s"name:${name} age:$age")
  }

  def Student1(): Unit = {
    println("一般方法被调用")
  }
}

构造器参数

在这里插入图片描述

代码演示

在这里插入图片描述

在这里插入图片描述

继承

在这里插入图片描述

代码演示

在这里插入图片描述

在这里插入图片描述

调用

在这里插入图片描述

多态

代码演示

在这里插入图片描述

在这里插入图片描述

测试

在这里插入图片描述

抽象类

在这里插入图片描述

代码演示

package com.tian.demo06

object Study03 {
  def main(args: Array[String]): Unit = {
    val student = new Student10
    student.eat()
    student.sleep()
    //person eat
    //student eat
    //stduent sleep
  }
}

//定义抽象类
abstract class Person1(){
  //非抽象属性
  val name:String ="person"
  //抽象属性
  var age:Int

  //非抽象方法
  def eat():Unit={
    println("person eat")
  }
  //抽象方法
  def sleep():Unit
}
//定义具体的实现子类
class Student10 extends Person1{
   var age: Int = 18

  override def sleep(): Unit = {
    println("stduent sleep")
  }

  //重写非抽象属性和方法
  override val name: String = "student"

  override def eat(): Unit = {
    super.eat()
    println("student eat")
  }
}

单例对象（伴生对象）

在这里插入图片描述

代码演示

package com.tian.demo06

object Study04 {
  def main(args: Array[String]): Unit = {
      val student=new Student9("zhangsan",18)
    student.printInfo() //zhangsan,18,atguigu

  }
}
//定义类
class Student9 (val name: String, val age: Int) {
  def printInfo() {
    println(s"$name,$age,${Student9.school}")
  }
}

//伴生对象
object Student9 {
  val school: String = "atguigu"
}

如果是private

class Student9 private(val name: String, val age: Int)

伴生对象

在这里插入图片描述

调用

在这里插入图片描述

单例模式

代码演示 饿汉式

在这里插入图片描述

在这里插入图片描述

懒汉式

在这里插入图片描述

特质Trait

在这里插入图片描述

在这里插入图片描述

代码演示

在这里插入图片描述

定义一个特质

在这里插入图片描述

在这里插入图片描述

注意Student13

在这里插入图片描述

测试

在这里插入图片描述

extends person with trail1 with trail 2

这三个里面方法冲突

方法冲突 extends 没有

谁在后返回谁( trail 2)

extends有 还是谁在后返回谁 ( trail 2)

在这里插入图片描述

特征自身类型

在这里插入图片描述

在这里插入图片描述

测试

在这里插入图片描述

扩展

在这里插入图片描述

枚举类和应用类

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

type重命名

在这里插入图片描述

xixihaha_coder
关注
专栏目录
Scala _09样例类(case classes)&隐式转换
乔治大哥的博客
10-19 561
样例类(case classes) 概念理解 使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类。实现了类构造参数的getter方法（构造参数默认被声明为val），当构造参数是声明为var类型的，它将帮你实现setter和getter方法。 样例类默认帮你实现了toString,equals，copy和hashCode等方法。 样例类可以new, 也可以不...
scala学习
weixin_42112224的博客
08-14 221
Scala语言的核心知识，包括scala语言的基础、数据结构高阶特性等。 scala换行符可省略；scala 的main在object中；scala文件名可以不予对象名匹配但是建议匹配。 scala中有8种类型：Byte/Short/Int/Long/Float/Double/Char/Boolean。这些都是类。 对应的RichInt或者RichChar。 1.max（10）;1.min(10);1.to(10);1.until(10)。"11".toInt; Any是所有类的超类，AnyV
Scala学习笔记
peace唠叨
03-13 2932
本文主要是我在阅读快学Scala（Scala for the Impatient）中所记录的笔记，暂缺：十六、十九、二十二。神奇的Scala：面向表达式编程。
Scala基础学习入门
clamaa的专栏
09-24 154
  从技术上来讲，scala程序并不是一个解释器，你在命令行中输入的内容被快速地编译成字节码，然后这段字节码交给Java虚拟机执行。   变量声明：   val val不能再继续赋值， 鼓励使用该命令方式 var 生命周期中可以被多次赋值 大多数程序并不需要那么多var变量   scala中变量或函数的类型总是写在变量或函数名称后面：   ...
ScalaMLExamples:使用微风库的Scala机器学习Coursera示例
05-03
这个项目的目的是帮助学习者更好地理解和应用机器学习算法在Scala中的实现。 首先，我们需要了解Scala的基础。Scala是一种多范式编程语言，结合了面向对象和函数式编程的特点，具有强大的表达能力和类型安全。它的...
scala-exercises：学习Scala的简单方法
02-05
通过简单的代码示例学习概念。 解决方案：每个练习都是必须成功通过的单元测试-通过填写空白来完成练习。 实时验证您的答案后，即可收到即时反馈。 分享：成功完成所有练习后，系统将认为类别完整。 在进入下一个...
Scala_Learning：Scala学习课程
02-16
Scala的类和对象支持单例设计模式，使得全局状态的管理更为简单。特质是Scala中的一个独特特性，类似于接口但可以包含实现，它们可以被多重继承，解决了Java中接口的局限性。此外，Scala还引入了类型推断，减少了...
scala：scala代码
02-10
在"scala: scala代码"的描述中，我们可以推测这是一个关于Scala编程语言的学习资源或者项目源代码。 1. **面向对象编程**：Scala是基于Java虚拟机（JVM）的语言，因此它兼容Java的所有类库。它支持类、对象和继承等...
Scala学习之路（一）
11-03
这篇文章是Scala方面的，scala的windows安装，scala的linux安装，以及第一个scala程序
Scala学习
小强签名设计 的博客
07-05 489
文章目录一、Windows下安装Scala 一、Windows下安装Scala   Scala是一种类似Java的纯面向对象的函数式编程语言，由于函数具有明确的确定输入对确定输出的关系，所以适合推理和计算，一切函数都可以看成一系列的计算组成，另外由于Scala函数是没有副作用和透明的，所以非常适合做多核并行计算和云计算，现在正被越来越多的应用到生产中   因为Scala运行在JVM上，所以应该首先配置好JDK环境，然后下面是Windows安装Scala环境的过程：   首先去官网http://www.sca
Scala学习（一）
qq_42337039的博客
03-02 2510
Scala基础语法 Scala与Java的最大区别是：Scala语句末尾的分号是可选的 我们可以认为Scala程序是对象的集合，通过调用彼此的方法来实现消息传递，理解类，对象，方法，实例变量的概念 对象：对象有属性和行为，对象是一个类的实例 类：类是对象的抽象，而对象是类的具体实例 方法：方法描述的基本的行为，一个类可以包含多个方法 字段：每个对象都有它唯一的实例变量集合，即字段，对象的属性通过给字段赋值来创建 交互式编程 脚本形式 创建一个HelloWorld.scala的文件来执行代码 objec
scala 学习【一】
qq_45494908的博客
01-22 348
-
简洁的scala
有梦
06-14 543
scala简洁吗？scala被认为有很高的代码密度，键入更少获得更多。
简洁的scala(oop)
大怀特的博客
10-12 299
文章目录类this别名&自身类型scala中的泛开和泛型函数scala中泛型在Spark中应用scala中类型变量Bounds代码类型和多态基础什么是静态类型？它们为什么有用？Scala中的类型参数化多态性Scala有秩1多态性类型推断变性 Variance边界量化高级类型视界（“类型类”）其他类型限制使用视图进行泛型编程上下文边界和 implicitly[]高阶多态性类型 和 特设多态性F-界多态性结构类型抽象类型成员类型擦除和清单案例分析: Finagle模式匹配匹配值匹配类型匹配类成员运算符符
Scala入门学习
最新发布
CSDN2022博客之星Top39；华为云博主7&，CSDN、稀土掘金、微信公众号、阿里云开发者社区、腾讯云社区、博客园、知乎、51CTO同名博主WHYBIGDATA；
07-06 1567
Scala入门学习
Scala必备学习
十五亿少女的心的博客
07-05 331
scala语言的介绍 scala是一门多范式的编程语言，即面对对象也是函数式编程（函数式编程：面对过程，编程函数） scala语言和Java语言的对比 相同点： Java和Scala可以无缝混编，都是基于jvm，都可以相互调用 不同点： Scala类型可以自动...
Scala编程入门：通过实例学习
这是一本关于Scala编程语言的学习指南，通过实例教学的方式来引导读者掌握Scala的基础和高级特性。作者是Martin Odersky，他在EPFL（瑞士洛桑联邦理工学院）的编程方法实验室工作。这本书涵盖了多个主题，旨在帮助...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值