2021-04-25

最新推荐文章于 2024-09-29 21:46:37 发布
最新推荐文章于 2024-09-29 21:46:37 发布
阅读量81 收藏
点赞数 1
分类专栏： scala 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52111247/article/details/116120663
版权

文章目录

Scala day02

流程控制（While，For）

While循环

  1. 与if语句不同，while语句没有返回值，即整个while语句的结果是Unit类型()
  2. 任何的语法结构都有值
    赋值语句的值也是Unit
package com.gc.scala.day02

/**
 * author guochao
 * date 2021/4/22 9:51
 */
object WhileDemo {
  def main(args: Array[String]): Unit = {
    var i: Int = 0
    val r: Unit = while (i < 10) {
      println(i)
      i += 1
      i
    }
    println(r)
  }
}

For循环

范围数据循环方式1（to）

基本语法

for(i <- 1 to 3){
  print(i + " ")
}

println()
（1）i 表示循环的变量，<- 规定to
（2）i 将会从 1-3 循环，前后闭合,[1,3]

package com.gc.scala.day02

/**
 * author guochao
 * date 2021/4/22 9:56
 */
object For1 {
  def main(args: Array[String]): Unit = {
    /*val a:String ="abc"
   for (c <-a){//遍历容器
     println(c)
   }*/
    //使用for输出1-100

    for (i <- 1 to 100) {
      println(i)
    }

    for (i <- 1 to 100 by 2) {
      println(i)
    }
    for (i <- 1 to 100 reverse) { //逆转，100到1
      println(i)
    }
  }
}
范围数据循环方式2（until）

基本语法

for(i <- 1 until 3) {
  print(i + " ")
}
 println()

（1）这种方式和前面的区别在于i是从1到3-1，[1,3)
（2）即前闭合后开

循环守卫

基本语法

for(i <- 1 to 3 if i != 2) {
  print(i + " ")
}
println()

说明：
（1）循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue。
（2）上面的代码等价

for (i <- 1 to 3){
	if (i != 2) {
		print(i + "")
	}
}

package com.gc.scala.day02

/**
 * author guochao
 * date 2021/4/24 15:59
 */
object For2 {
  def main(args: Array[String]): Unit = {
    //输出1-100的奇数
    //循环守卫
  for (i <- 1 to 100 if i % 2 == 1) {
      println(i)
    }
    for (i <- 1 until 3) { //[1,3)
      println(i)
    }
    for (i <- 1 to 100 if i % 2 == 0; j = i * i if j < 10000; k = j * j) {
      println(s"i=$i,j=$j,k=$k")
    }
  }
}
循环步长

基本语法

for (i <- 1 to 10 by 2) {
      println("i=" + i)
    }

说明：by表示步长
2）案例实操
需求：输出1到10以内的所有奇数

for (i <- 1 to 10 by 2) {
println("i=" + i)
}

输出结果

i=1
i=3
i=5
i=7
i=9
引入变量

基本语法

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

说明：
（1）for推导式一行中有多个表达式时，所以要加；来隔断逻辑
（2）for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下

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

2）案例实操
上面的代码等价于

for (i <- 1 to 3) {
    var j = 4 - i
    println("i=" + i + " j=" + j)
}
循环返回值
  1. 基本语法
val res = for(i <- 1 to 10) yield i
println(res)

说明：将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字
2. 案例实操
需求：将原数据中所有值乘以2，并把数据返回到一个新的集合中。

object TestFor {

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

        var res = for( i <-1 to 10 ) yield {
            i * 2
        }

        println(res)
    }
}

输出结果：

Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

package com.gc.scala.day02

/**
 * author guochao
 * date 2021/4/24 16:19
 */
object For5 {
  def main(args: Array[String]): Unit = {
    //得到一个序列： 1 4 9 16 .....100*100
    val r: IndexedSeq[Int] = for (i <- 1 to 100) yield {
      i * i
    }

    println(r)

    // "abcd"=>"AbBbCc"
    val s: IndexedSeq[String] = for (c <- "abcd") yield c.toString.toUpperCase + c
    println(s.mkString(""))
    //更加函数式
    println("abcd".map(c => c.toString.toUpperCase + c).mkString(""))

  }
}

函数

函数定义

val 函数变量名 :函数类型 = (参数名:参数类型, 参数名:参数类型…) => 函数体

val sum: (Int, Int) => Int = (x: Int, y: Int) => x + y

方法定义

def 方法名(参数名:参数类型, 参数名:参数类型) : [return 返回值类型] ={函数体}

def add(a:Int,b:Int=3,c:Int):Int=a+b+c

函数和方法的区别

  1. 核心概念
    （1）为完成某一功能的程序指令（语句）的集合，称为函数。
    （2）类中的函数称之方法。
  2. 案例实操
    （1）Scala语言的语法非常灵活，可以在任何的语法结构中声明任何的语法
    （2）函数没有重载和重写的概念；方法可以进行重载和重写
    （3）scala中函数可以嵌套定义
object TestFunction {

    // (2)方法可以进行重载和重写，程序可以执行
    def main(): Unit = {

    }

    def main(args: Array[String]): Unit = {
        // （1）Scala语言的语法非常灵活，可以在任何的语法结构中声明任何的语法
        import java.util.Date
        new Date()

        // (2)函数没有重载和重写的概念，程序报错
        def test(): Unit ={
            println("无参，无返回值")
        }
        test()

        def test(name:String):Unit={
            println()
        }

        //（3）scala中函数可以嵌套定义
        def test2(): Unit ={

            def test3(name:String):Unit={
                println("函数可以嵌套定义")
            }
        }
    }
}

方法转换成函数(_)

package com.gc.scala.day02

/**
 * author guochao
 * date 2021/4/24 17:15
 */
object High3 {
  def main(args: Array[String]): Unit = {
    //把方法转化成函数，没有环境，就必须手动完成
    val add1:(Int,Int)=>Int=add _
    //这个时候也是把方法转成了函数，是Scala自动完成的
    val add2:(Int,Int)=>Int=add
    println(add1(10, 20))
    println(add2(10, 20))

    val r: Int= foo(add _ )
    println(r)

    //    foo1(add1 )
  }
  def add1():Unit=println("add1....")
  def foo1(op:() => Unit):Unit=op()

  def foo(op:(Int,Int)=>Int):Int={
    op(10,20)
  }
  def add(a:Int,b:Int):Int=a+b


}

函数声明

  1. 函数声明
    （1）函数1：无参，无返回值
    （2）函数2：无参，有返回值
    （3）函数3：有参，无返回值
    （4）函数4：有参，有返回值
    （5）函数5：多参，无返回值
  2. 案例实操
package com.atguigu.chapter06

object TestFunctionDeclare {

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

        // 函数1：无参，无返回值
        def test(): Unit ={
            println("无参，无返回值")
        }
        test()

        // 函数2：无参，有返回值
        def test2():String={
            return "无参，有返回值"
        }
        println(test2())

        // 函数3：有参，无返回值
        def test3(s:String):Unit={
            println(s)
        }
        test3("jinlian")

        // 函数4：有参，有返回值
        def test4(s:String):String={
            return s+"有参，有返回值"
        }
        println(test4("hello "))


        // 函数5：多参，无返回值
        def test5(name:String, age:Int):Unit={
            println(s"$name, $age")
        }
        test5("dalang",40)
    }
}

函数参数

  1. 案例实操
    （1）可变参数
    （2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
    （3）参数默认值
    （4）带名参数
object TestFunction {

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

        // （1）可变参数
        def test( s : String* ): Unit = {
            println(s)
        }

        // 有输入参数：输出 Array
        test("Hello", "Scala")

        // 无输入参数：输出List()
        test()

        // (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后
        def test2( name : String, s: String* ): Unit = {
            println(name + "," + s)
        }
        /*
        可变参数一般放置在最后
        def test2( s: String*,name : String ): Unit = {
            println(name + "," + s)
        }
        */
        test2("jinlian", "dalang")

        // (3)参数默认值
        def test3( name : String, age : Int = 30 ): Unit = {
            println(s"$name, $age")
        }

        // 如果参数传递了值，那么会覆盖默认值
        test3("jinlian", 20)

        // 如果参数有默认值，在调用的时候，可以省略这个参数
        test3("dalang")


        def test4( sex : String = "男", name : String ): Unit = {
            println(s"$name, $sex")
        }

        // scala函数中参数传递是，从左到右
        // 一般情况下，将有默认值的参数放置在参数列表的后面
//        test4("wusong")

        //（4）带名参数
        test4(name="ximenqing")
    }
}
  1. 位置参数：在Java和Scala中，默认传递函数参数，是按照位置来的
package com.gc.scala.day02

/**
 * author guochao
 * date 2021/4/24 16:34
 */
object Fun4 {
  def main(args: Array[String]): Unit = {
    println(add(1, 2, 3))
    println(add(10, 20, 3))
    println(add(100, 20, 3))
   // println(add(100,20))  位置参数
    println(add(10, c = 100))

  }
  def add(a:Int,b:Int=3,c:Int):Int=a+b+c
  //  def add(a:Int,b:Int,c:Int=3):Int=a+b+c

}

高阶函数

定义：参数为函数的函数称为高阶函数

object TestFunction {

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

        //高阶函数————函数作为参数
        def calculator(a: Int, b: Int, operater: (Int, Int) => Int): Int = {
            operater(a, b)
        }

        //函数————求和
        def plus(x: Int, y: Int): Int = {
            x + y
        }

        //方法————求积
        def multiply(x: Int, y: Int): Int = {
            x * y
        }

        //函数作为参数
        println(calculator(2, 3, plus))
        println(calculator(2, 3, multiply))
    }
}

匿名函数

1.匿名函数：
没有名字的函数，就是匿名函数
用处：
1.作为实参，直接传递给高阶函数
2.直接作为高阶函数的返回值

package com.gc.scala.day02

/**
 * author guochao
 * date 2021/4/24 17:23
 */
// 快捷键
//  自动格式化：alt+ctrl+l
object High4 {
  def main(args: Array[String]): Unit = {
    val a:()=>Unit=()=>println("aaaa")
    foo(a)
    foo(()=>{println("匿名函数")})

  }

  def foo(f: () => Unit): Unit ={
    f()
  }

}
/*
* 1.匿名函数：
没有名字的函数，就是匿名函数
用处：
1.作为实参，直接传递给高阶函数
2.直接作为高阶函数的返回值*/

闭包

一个函数，如果访问了外部的局部变量，则这个函数和他访问的局部变量称为一个闭包，
闭包会阻止外部局部变量的销毁，可以把局部变量的使用延伸到函数的外部

package com.gc.scala.day02

/**
 * author guochao
 * date 2021/4/24 17:45
 */
object Closure {
  def main(args: Array[String]): Unit = {
    val f:Int=>Int=foo()
    val r:Int=f(20)//能够访问到a,是因为闭包的存在
    println(r)
  }
  def foo()={
    var a:Int=10
    (b:Int)=>a+b
  }
}
/*一个函数，如果访问了外部的局部变量，则这个函数和他访问的局部变量称为一个闭包，
闭包会阻止外部局部变量的销毁，可以把局部变量的使用延伸到函数的外部*/
Starry sky325
关注
专栏目录
2021-11-04
HHH_____的博客
11-04 2382
kettle发送邮件失败 《数据清洗》黑马程序员编著第三章实操。 报错如下 发送邮件 - ERROR (version 9.0.0.0-423, build 9.0.0.0-423 from 2020-01-31 04.53.04 by buildguy) : Problem while sending message: javax.mail.MessagingException: Could not connect to SMTP host: smtp.qq.com, port: 465, respons
2021-04-21
qq_56102648的博客
04-21 843
2021-04-09
HCZ_hhh的博客
04-09 435
2021-01-04
wubaoyu123的博客
01-04 2268
博客园Logo 首页 新闻 博问 专区 闪存 班级 代码改变世界 搜索 注册 登录 返回主页 知了一笑 博客园 首页 新随笔 联系 订阅 管理 数据仓库组件：Hive环境搭建和基础用法 本文源码：GitHub || GitEE 一、Hive基础简介 1、基础描述 Hive是基于Hadoop的一个数据仓库工具，用来进行数据提取、转化、加载，是一个可以对Hadoop中的大规模存储的数据进行查询和分析存储的组件，Hive数据仓库工具能将结构化的数据文件映射为一张数据库表，并提供SQL查询功能，能将SQL语句转变成
2021-01-18
weixin_54641072的博客
01-18 1856
找程序猿哥哥！！！！编制App或者小程序
2021-05-05
樊金良的博客
05-05 765
你需要努力，fighting！
2021-03-15
weixin_44902539的博客
03-15 1276
好网站 https://blog.csdn.net/u013317445/article/details/88196373?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-6.control&dist_request_id=1328641.48931.16157665162059593&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-
2021-04-22
m0_56229717的博客
04-22 1532
题目要求 LSW1 ; r state BACKUP changed to MASTER, because of protocol timer expired. (Interface= Vlanif2, VrId=1, InetType=IPv4) [sw1-Vlanif2]vrrp Apr 22 2021 15:39:16-08:00 sw1 DS/4/DATASYNC_CFGCHANGE:OID 1.3.6.1.4.1.2011...
网络攻防｜CVE-2021-42287、CVE-2021-42278域内提权
weixin_42282189的博客
12-20 2636
作者： r0n1n 免责声明：本文仅供学习研究，严禁从事非法活动，任何后果由使用者本人负责。 0x01 漏洞原理 Microsoft Windows Active Directory 域服务权限提升漏洞（CVE-2021-42278、CVE-2021-42287）攻击者可利用该漏洞将域内的普通用户权限提升到域管理员权限，造成风险和危害极大。 漏洞情报来源： 1、影响版本 CVE-2021-42278 ￮ Windows Server 2012 R2 ￮ Windows Server 2012 (S.
淘宝放单源码Java-arthas-all-2021-04-25:arthas-all-2021-04-25
06-07
淘宝放单源码Java 阿尔萨斯 Arthas是阿里巴巴开源的 Java 诊断工具。 Arthas 允许开发人员在不修改代码或重新启动服务器的情况下解决 Java 应用程序的生产问题。...很多时候，生产系统网络无法从本地开发环境访问。...
Chipsbank APTool量产工具最新版CBM219X-UMPToolV7200(2021-04-26)
04-27
Chipsbank APTool量产工具最新版CBM219X-UMPToolV7200(2021-04-26)
Serial-COM25_2021-04-04_14-37-43.log
04-04
Serial-COM25_2021-04-04_14-37-43.log
Scala 字符串
wjs2024的博客
09-29 448
Scala 是一种多范式的编程语言，它结合了面向对象和函数式编程的特点。在 Scala 中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能更改它。Scala 字符串由 Java 字符串支持，因此 Scala 字符串的方法与 Java 字符串的方法非常相似。
SpinalHDL之语义(Semantic)（三）
m0_59092412的博客
09-29 550
⼀、简介(Introduction)SpinalHDL背后的语义学很重要, 学会语义你就能理解在这些情景背后到底发⽣了什么, 并且如何去控制它。这些语义通过以下⼏条规则定义：
PHP基于微信公众号的点餐系统源码.zip
10-03
用Yii2框架做的一个微信公众号点餐系统，商家接入管理后台之后就可以在后台添加菜式的类型和菜式的名称，客户在微信扫描二维码关注公众号就可以在公众号点餐，下单时提交餐桌号还有相应的信息到商家后台，商家在后台可以查看到订单信息 提示，因为个人原因缺乏支付功能，支付代码已经完成
基于Delaunay三角剖分的大学生方程式无人赛车路径规划算法
10-03
【作品名称】：基于Delaunay三角剖分的大学生方程式无人赛车路径规划算法 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 基于 Delaunay 三角剖分的路径规划算法：将锥桶位置视为离散点，构建 Delaunay 三角，然 - 第一列为锥桶序号，内外侧锥桶已经分别按照赛道顺序排序 - 第二列为锥桶类型（颜色），`2` 为外侧锥桶（蓝色，位于车辆行驶方向的左侧）、`11` 为内侧锥桶（黄色，位于车辆行驶方向的右侧） - 第三四列为 x 坐标与 y 坐标，单位为 [m] 在真实场景中，安装在赛车上的传感器的感知范围是有限的，并不能一次获取所有锥桶位置。因此，设计一个变量 `interval`，用于控制每次规划时考虑的锥桶数量。（换言之，将整条赛道划分为若干个路段，每次只在一个路段内进行规划。）如图所示，若 `i 【资源声明】：本资源作为“参考资料”而不是“定制需求”，代码只能作为参考，不能完全复制照搬。需要有一定的基础能够看懂代码，能够自行调试代码并解决报错，能够自行添加功能修改代码。
MATLAB 实现的基于随机森林（Random Forest, RF）的工业增加值预测模型的详细实例（包含详细的完整的程序和数据
10-03
主要内容：本文介绍了一个完整的案例，展示用MATLAB的TreeBagger函数实现基于随机森林的方法来进行工业增加值的预测。该模型考虑了生产总值、投资以及消费等因素，通过详细的操作步骤生成了相关数据，训练与评估了随机森林模型。文中还提供了完整的源代码和示例，方便开发者动手实践和学习如何利用统计和机器学习工具箱进行预测任务。 适用人群：熟悉基本MATLAB语法，具有一定数据分析经验和统计学基础知识的研发和工程技术人员。 使用场景及目标：适合用于工业经济分析师或者研究学者们在需要快速预测行业增长趋势时借鉴，特别当涉及到多因素复杂变量情况下时。 补充说明：此案例还包括划分训练集与验证集，计算如均方误差（RMSE）等评估指数帮助检验模型准确度的功能部分，便于初学者快速搭建模型，理解每个阶段的工作细节及其重要性。
基于Python的新能源汽车应用场景，使用神经网络训练锂离子电池使用相关数据并预测电池的当前最大容量.zip
最新发布
10-03
基于Python的新能源汽车应用场景，使用神经网络训练锂离子电池使用相关数据并预测电池的当前最大容量
使用python中的pymsql完成如下：表结构与数据创建 1. 建立 `users` 表和 `orders` 表。 `users` 表有用户ID、用户名、年龄字段，（id，name，age） `orders` 表有订单ID、订单日期、订单金额，用户id字段。（id，order_date，amount，user_id） 2 两表的id作为主键，`orders` 表用户id为users的外键 3 插入数据 `users` (1, '张三', 18), (2, '李四', 20), (3, '王五', 22), (4, '赵六', 25), (5, '钱七', 28); `orders` (1, '2021-09-01', 500, 1), (2, '2021-09-02', 1000, 2), (3, '2021-09-03', 600, 3), (4, '2021-09-04', 800, 4), (5, '2021-09-05', 1500, 5), (6, '2021-09-06', 1200, 3), (7, '2021-09-07', 2000, 1), (8, '2021-09-08', 300, 2), (9, '2021-09-09', 700, 5), (10, '2021-09-10', 900, 4); 查询语句 1. 查询订单总金额 2. 查询所有用户的平均年龄，并将结果四舍五入保留两位小数。 3. 查询订单总数最多的用户的姓名和订单总数。 4. 查询所有不重复的年龄。 5. 查询订单日期在2021年9月1日至9月4日之间的订单总金额。 6. 查询年龄不大于25岁的用户的订单数量，并按照降序排序。 7. 查询订单总金额排名前3的用户的姓名和订单总金额。 8. 查询订单总金额最大的用户的姓名和订单总金额。 9. 查询订单总金额最小的用户的姓名和订单总金额。 10. 查询所有名字中含有“李”的用户，按照名字升序排序。 11. 查询所有年龄大于20岁的用户，按照年龄降序排序，并只显示前5条记录。 12. 查询每个用户的订单数量和订单总金额，并按照总金额降序排序。
06-03
cur.execute('SELECT SUM(amount) FROM orders WHERE order_date BETWEEN "2021-09-01" AND "2021-09-04"') print(cur.fetchone()[0]) # 6. 查询年龄不大于25岁的用户的订单数量，并按照降序排序。 cur.execute('''...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值