scala的使用

于 2022-12-28 20:40:58 发布
阅读量93 收藏
点赞数
分类专栏： scala 文章标签： scala 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lcatake/article/details/128473736
版权

scala的使用

1.什么是scala

2.数据类型

1.字符串

2.数值

3.布尔

4.tuple 元组

5.Map键值对

3.scala顶层数据接口

4.语法

1.值 val

2.变量 var

3.打印

4.变量与值的初始化

5.数据类型转换

6.数据类型判断

7.集合

8.方法的调用

9.流程控制

10.方法与函数

11.类

1.属性，方法，构造器

2.伴生类和伴生对象

3.构造器

4.继承

5.抽象类

6.特质

12.高阶函数

1.函数的创建

2.相互转换

3.自定义高阶函数

4.高阶函数

1.什么是scala
1.Scala是一门多范式的编程语言
2.一种类似java的编程语言
3.实现可伸缩的语言
4.并集成面向对象编程和函数式编程的各种特性
2.数据类型
1.字符串：String
2.数值：Int、Long、Float、Double
3.布尔：Boolean
4.tuple 元组
1.创建
val a = (1,2,3,4)
(,)=>最多22个
2.取值a._1
val list = arr.map(x => x.map(t =>(t._1,t._2 + 2)))
5.Map键值对
Map(k->v)
集合，元素一对一对的
1.值不可变
1.创建
val b=Map(“zs” ->12,“ls” ->15)
2.取值
1.b.get(“zs”)
2.b.getOrElse(“zs”,“默认值”)
3.补充Option：要么有要么无
Some =》有
None =》无

    2.值可变
        1.创建
            val m1 = scala.collection.mutable.Map("zs" ->12,"ls" ->15)
        2.取值
            b.get("zs")
        3.改值
            b("zs")=10

3.scala顶层数据接口
1.Any => java Object
1.AnyVal 值类型
unit =》void （返回值为空）
2.AnyRef 引用类型
String
3.scala底层数据接口
Nothing
1.Nothing 值
2.Null => Nothing 引用
4.语法
1.值 val
1.val 变量名：数据类型 = 值
val username:String= “hhh”
2.不可重写
username=“mmm” （错误）

2.变量 var
    var 变量名：数据类型 = 值
    var age:Int= 19

3.打印
    1.换行   println
    println(username)
    2.不换行 print
    print(age)

4.变量与值的初始化
    1.显示初始化
        val num =1
    2.占位符：_
        1.val name:String=_
        2.需要明确是什么数据类型
          val age=_ (错误)


5.数据类型转换
    1. asInstanceOf[
        val age = i.asInstanceOf[Double]
    2.toxxx
        val b = i.toDouble
6.数据类型判断
    isInstanceOf
    name.isInstanceOf[String]
7.集合
    1.scala集合包
        1.可变（长度）
        2.不可变（长度）
    2.Array
        1.定长数组 =》不可变
        Array
            1.new
                创建
                val arr=new Array[String](10)
            2.非new
                创建
                    val arr2=Array[String]("1","2","3")
            3.增添
                arr(0)="zs"
            4.数组长度
                arr.length
            5.遍历
                1.for(elem <-arr2){
                  println(elem)
                  }
                2.for(i <- 0 until arr2.length){
                    println(arr2(i))
                3.arr2.foreach(println(_))
                
                4.arr2.indices.map(i =>{
                  println(arr2(i))
                 })
            6.api
                1.元素反转 
                  1.reverse
                  2.自己编写
                    for(i <- (arr2.length-1).to(0,-1)){
                    println(arr2(i))
                    }

                2.数组相加
                   ++ 类似的数据结构拼接
                3.常见api 
                   max，min，sum
                   xxx.max
                4.把数据内元素转换成字符串输出
                    mkString
                    val res=arr2.mkString("{",",","}")
                    println(res)

                
        2.变长数组 =》可变
        ArrayBuffer
            1.创建()
            val a = ArrayBuffer[Int]
            2.添加
             a +=1
            3.insert 
             a.insert(3,4,5,6,7)
             从第三个位置插入4，5，6，7
            4.remove
            a.remove(2,1)
            从第二个位置开始删除1个
        
        2.Range
             1.快速构建集合
            返回值都是range：
                1.to [] 左闭右闭 1~10
                val r1: Range.Inclusive = 1 to 10
                2.until [) 左闭右开 1~9
                val r2: Range = 1 until 10
        3.List
            1.长度不可变：List                
                1.Nil 是不可变size为0的List
                2. :: 追加元素
                   Nil
                   val a = 1:: Nil
                   val b =(1,2,3)::Nil
                3.api
                    head:取出List的第一个元素
                    tail：取出List非第一个元素以外的所有
                    package com.bigdaya.scala   
                    object T9  {
                    def main(args: Array[String]): Unit = {
                    println(sum(1,2,3,4))
                    }
                    def sum(nums:Int*):Int={
                    if(nums.length==0){
                    0
                    }else{
                    nums.head+sum(nums.tail:_*)
                    }
                    }
                    }
            2.长度可变：ListBuffer
                1.创建val l1 = ListBuffer[Int]()
                2.添加
                  l1 +=1
                  l1 +=(2,3,4)
                  l1 ++=List(5,6,7)
                3.Set 去重
                  无序 不可重复的集合
                  val a = Set(1,1,2,2,3,3,4,4,4)

    2.
        seq
        set
        Map


8.方法的调用
    1.xxx.method
    2.xxx method

9.流程控制
    1.分支结构
        1.if else
            val score = 80
            if(score >= 90){
              println("优秀")
            }
            else if (score >= 60){
              println( "良")
            }else {
              println("不及格")
            }
        注意：没有三元运算符 xxx?x:y


    2.循环
        1.for
            for (elem <- arr){
            println(elem)}
        2.while
            val iterator = arr.toIterator
            while(iterator.hasNext){
            val item = iterator.next()
            println(item)
        3.算子
            arr.foreach(println(_))
10.方法与函数

    1.def 方法
        1.语法结构
        def 方法名(参数名:参数类型):返回值类型={方法体}
        def sum(x:Int,Y:Int):In  t={
        x+y
        }
        注意：scala里面默认方法体的最后一行作为该方法的返回值，不需要写return
        2.调用
        val xxx:数据类型=值 ，方法返回值类型 可以进行 类型推断   
        3.方法 入参
        1.默认参数
            def write(x: String="null") = {
            println(x)}
            注意：如果有多个参数，默认参数放到最后

        2.可变参数
            def size(x:Int*) = {
            println(x.size)
            }
            注意：如果有多个参数，默认参数放到最后
            val arr = Array(1, 2, 3, 4)
            size("可变参数",arr:_*)

            def size(t:String,x:Int*) = {
            println(t+"==>"+x.size)
            }

    2.val 函数
        函数：本质就是一种特殊的方法
        1.语法结构
        val f1=(x:Int,y:Int)=>{
        x+y
        } 
        2.调用
        println(f1(1, 2))
11.类
    1.属性，方法，构造器
        object T1 {
        def main(args: Array[String]): Unit = {
        val dl: _root_.com.bigdaya.scala.T1.Dl2262 = new Dl2262
        dl.name="zs"
        println(dl.age)
        dl.listening("ll")
        }
        class Dl2262{
        var name:String=_
        val age:Int=20
        private val gender="男"
        def listening(teacher:String)={
        println(name+"is listening of" + teacher )
        }
        }
        }
    2.伴生类和伴生对象
        1.基本使用
            class 名称 是 object的伴生类
            object 名称 是 calss的伴生对象
            class A ==》普通类
            object A =》静态类
        2.常用操作
            apply()方法

            object T3 {
            def main(args: Array[String]): Unit = {
            val test = ApplyTest
            test.apply()
            val test1 = new ApplyTest
            test1.apply()
            }
            class  ApplyTest{
            def apply() = {
            println("class apply...")               
            }
            }
            object  ApplyTest{
            def apply(): ApplyTest = {
            println("object apply...")
            new ApplyTest()
            }
            }
            }

            object apply...
            class apply...
    3.构造器
        1.主构造器
         class 类名(参数列表)
         参数列表 =》参数名：参数类型
            object T4 {
            def main(args: Array[String]): Unit = {
            val p1= new Person("zs",19)
            p1.job="zz"
            println(p1.age+"\t"+p1.job+"\t"+p1.name)
            }
            class Person(val name:String,val age:Int){
            var job:String=_
            }
            }

        2.附属构造器
            1.添加附属构造器
                def this(参数列表):
                        1.每个附属构造器第一行必须调用主构造器或者 其他的附属构造器

                object T4 {
                 def main(args: Array[String]): Unit = {
                val p1= new Person("zs",19)
                p1.job="zz"
                println(p1.age+"\t"+p1.job+"\t"+p1.name)
                val ls = new Person("ls", 20, "NBL")
                println(ls.age+"\t"+ls.age+"\t"+ls.team)
                }
                class Person(val name:String,val age:Int){
                var job:String=_
                var team=""
                def  this(name:String,age:Int,team:String)={
                this(name,age)
                this.team=team
                }
                }
                }
    4.继承
        extend
        需要添加父类元素
        class B(name:String,val gender:String) extends A(name)

                object T5 {
                def main(args: Array[String]): Unit = {
                val zs = new B("zs","man")
                println(zs.gender)
                println(zs.age)
                zs.f01("1111")
                zs.f02("2222")
                }
                class A(name:String){
                val age:Int=10
                def f01(parm:String)={
                println(parm+"\t"+name)
                }
                }
                class B(name:String,val gender:String) extends A(name){
                def f02(parm: String) = {
                println(parm + "\t" + name)
                }
                }
                }
    5.抽象类
        1.定义一个多个方法 没有实现
        2.不能new

                object T6 {
                def main(args: Array[String]): Unit = {
                val p: Person = new p1
                p.dosomeing
                }
                abstract class Person{
                def dosomeing               
                val name:String
                }
                class p1 extends  Person{
                override def dosomeing={
                println("1111")
                }
                override val name:String="LS"
                }
                }
    6.特质=> java 接口 =》对一个类的补充+某一类事务的共性
        1.定义一个多个方法 可以实现也可以不实现
        2.extends A with B with C
                
                object T7 extends  TestMethod{
                def main(args: Array[String]): Unit = {
                rintln(sum(1, 2))
                }
                override def f1 = {
                }
                }

                trait TestMethod {
                val name=""
                def sum(x:Int,y:Int)={
                x+y
                }
                def f1
                }

12.高阶函数
    scala 高阶api  单线程
    spark core =》算子 多线程
    函数 是特殊的一种方法 
    方法 是特殊的一种函数 
    他们之间可以进行相互转换 
    1.函数的创建
    val f1=(x:Int,y:Int)=>{x+y}
    val f1:(Int,Int):Int=(x:Int,y:Int)=>{X+Y}
    2.他们之间可以进行相互转换
    val addFunc2: (Int, Int) => Int = add _
    3.自定义高阶函数
    当一个方法的参数是函数那么这个方法是高阶函数
        def foo(f1: (Int, Int) => Int)={
        println(f1(10, 30))
        }
         foo(addFunc2)
    4.高阶函数
        1.map 一一映射 
            val arr = Array(1, 2, 3, 4)
            val arr2  = arr.map(_* 2)
        2.foreach 遍历/输出
            1.打印到控制台
            2.mysql
            arr.foreach(println(_))
        3.filter 过滤
        arr.map(x=>x*2).filter(x=>x>4)
        4.flatMap = flatten+map
          一一映射
          flatMap与map的区别
            1.flatMap会"打破原来数据结构" => 递归 "压扁操作"
                map不会
            val ints: Array[Int] = arr.flatMap(x => x.map(x => x * 2))

            Array(2,4,6,8,10,12)
        5.reduce
          归约：按照指定的业务逻辑，两两数据上去
          先对元素1 和元素2 做操作 再讲结果 对元素3做操作形成新的结果 
          arr.reduce((x,y)=>x+y)
          x 第一个运输
          y 下一个元素
          2.补充
            reduceLeft
            reduceRight 
        6.groupBy
            自定义分组
            arr.groupBy(x=>x._1)
            以第一个元素分组
        7.mapVakyes
        一一映射
            1.map作用在value上
            2.数据为kv数据类型【Map键值对/tuple2】
            统计单词次数
            val wordGroupBy = arr.groupBy(x => x_1)
            wordGroupBy.mapValues(value=>value.map(x=>x._2).sum)
        8.sortBy
            自定义排序
            降序
             arr.sortBy(x=> -x)
        9.字符串插值
        println(s"xxx_${str}")
       
        10.case class 样例类
            class 与case class
            1.case class 不用new
            2.case class默认实现了序列化【重要】
            3.case classs equals,toString,hashcode
        11.模式匹配
           java swith case

           scala：
                1.匹配内容
                	xxx  match {
	                case xx =>println    
	                case xxx =>println
                    case _ =>println
                 }
                2.匹配类型
                 	xxx  match {
	                case xx:Int =>println    
	                case xxx:String =>println
                    case _ =>println
                 }                   
                3.匹配集合
                 	xxx  match {
	                case x::y::Nil=>println    
	                case "zs"::Nil =>println
                    case _ =>println
                 }                   
                4.匹配case class
                 	xxx  match {
	                case xx =>println    
	                case xxx =>println
                    case _ =>println
                 }      
        12.偏函数
            PartialFunction
            定一个方法，返回值是偏函数{
                方法体：一堆case语句
            }
            A:表示输入函数类型
            B：表示输出函数类型 
            object T9 {
            def main(args: Array[String]): Unit = {
            val arr = Array("spark", "hive", "flink")
            val item = arr(Random.nextInt((arr.length)))
            println(item)
            println(teacher(item))
            }
            def  teacher:PartialFunction[String,String]={
            case "spark" => "1111"
            case "hive" => "222"
            case _ => "333"
            }
            }
        13.柯力化 currying
           是必然发生的结果
           def sum(x:Int,y:Int)

           柯力化
           def sum(x:Int)(y:Int)
        14.io 读写url
            拿取后的内容只能操作一次
            object T9 {
            def main(args: Array[String]): Unit = {
            val content: BufferedSource = Source.fromFile("idea/data/wc.data")
            val lines= content.getLines()
            for (line <- lines){
            println(line)
            }
            }
            }
        15.隐士转换
            A类 =>B类
            B对A已有的东西进行增强 
            1.隐士参数【作用到方法参数上】

            2.隐士类型转换【作用到def上】
            使man有了suoerman的功能
            object T9 {
            def main(args: Array[String]): Unit = {               
            implicit  def man2superman(man:Man):SuperMan={
            new SuperMan(man.name)
            }
            val zzx = new SuperMan("zzx")
            zzx.fly()
            val zs= new Man("zs")
            zs.fly()
            }
            class Man(val name: String)
            class SuperMan(name: String) {
            def fly() = {
            println("${name} can fly ....")
            }
            }
            }

            3.隐士类 【作用到class上】【高危】
        16.泛型
            类型的约束
            
            1. abstract class  MSG[S](content:S)
            class  WeChat(content:String)extends MSG(content)
            class  QQChat[Int](content:Int)extends MSG(content)
            class  ZFBChat(content:BigInt)extends MSG[BigInt](content)

            2.  class GG[A,B,C]( val face:A,val heigh:B,val         clother:C){
            override def toString: String = face+"\t"+heigh+clother}
            3.上界 <T extends Test>
                    T是Test的子类
            4.下界 <T  super Test>
                    T可以是Test的父类
            5.逆变 vs 协变
              -        +   


        17.枚举
            object T10 {
            def main(args: Array[String]): Unit = {           
            val zs = new GG[FaceEnum, Int, Double](FaceEnum.A, 122, 77)
            }
            class GG[A,B,C]( val face:A,val heigh:B,val clother:C){
            override def toString: String = face+"\t"+heigh+clother
            }
            //枚举的定义
            object  FaceEnum extends  Enumeration{
            type FaceEnum=Value
            val A,B,C,D=Value
            }           
            }
        18.排序
            1.Ordering =>Comparator
            2.Ordered =>Comparable
lcatake
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala 使用IDEA开发
01-20
使用IntelliJ IDEA（简称IDEA）作为开发环境可以提供高效、便捷的Scala开发体验。以下是如何在IDEA中配置和使用Scala进行开发的详细步骤： **安装Scala插件** 1. 打开IDEA，进入设置界面（Preferences on macOS，...
Scala -- Scala中“_“的用法总结(持续更新)
erainm
09-22 2257
1. 导包时,多引用的方法,和java中的*类似 例如: import scala.collection.mutable._ 2. 访问元组时,和值一起使用表示第几个元素 例如: val/var 元组名 = (元素1, 元素2, 元素3....) //获取第一个元素 元组名._1 //获取第二个元素 元组名._2 3. 在方法转函数时,在方法名后面用<空格>加 ‘_’ 来进行转换 例如: def method1(x:Int,y:Int):Int = x+y val f2 = method1&
Scala语言的用法
weixin_52923290的博客
05-10 706
目录 一、Scala与Java语言的关系 二、运行环境搭建 三、Scala语言具体用法 1、输出语法 2、变量使用和转换 3、方法（函数） 4、循环判断 5、IO流 6、异常，一般函数异常Scala已经抛出，不用在手动抛出。 7、连接数据库jdbc 8、字符串转换json格式 9、类的重载和重写 10、case类 11、apply（）方法 一、Scala与Java语言的关系 Java和Scala语言本质上是一样的，Scala就是在Java的基础上对Java语言进行
Scala入门基础
Anchor
08-30 3092
Scala是一门多范式的编程语言。是一种纯面向对象的语言，每个值都是对象。同时也是一种函数式语言，其函数也能当成值来使用。由于Scala整合了面向对象和函数式编程的特性，因此Scala相对于Java、C#、C++等其它语言更简洁。本文章将通过简单的案例教会大家如何简单的使用Scala编程，大家也可以模仿案例动手实践有助于自己入门学习 Scala也是运行在JVM上的语言，所以必须确认环境中安装了Java Windows安装直接在官网下载后，在本地高级系统设置中添加bin目录地址环境即可............
Scala
涵死的博客
11-27 1万+
一 Scala安装与配置 1 安装 2 配置IDEA 二 Scala基础 1 Hello Scala 11 IDEA运行HelloScala程序 12 控制台运行HelloScala程序 2 声明值和变量 3 常用类型 31 常用类型介绍 32 常用类型结构图 4 算数操作符重载 5 调用函数与方法 6 option类型 三 控制结构和函数 1 if else表达式 2 w
Scala中"=>"的使用小结
Nelson_hehe的博客
12-01 999
scala中"=>"的使用 1.场景一：定义函数表达式 2.场景二：函数传名调用（直接将未计算的表达式作为参数传入） Scala的解释器在解析函数参数(function arguments)时有两种方式： ①call-by-value： 先计算参数表达式的值，再应用到函数内部； ②call-by-name： 将未计算的参数表达式直接应用到函数内部。 在进入函数内部前，传值...
libgdx-scala-template:用于从Scala使用libgdx的模板项目
05-22
《使用Scala和libgdx构建游戏模板项目》 在当今的数字娱乐产业中，游戏开发已经成为一项技术密集型的工作，而LibGDX作为一款强大的跨平台游戏开发框架，深受开发者们的喜爱。配合强大的编程语言Scala，我们可以创建...
Scala入门之List使用详解
08-25
Scala入门之List使用详解 Scala是一种函数式风格与面向对象共存的编程语言，在Scala中，List是不可变的对象，具有递归结构，具有协变性。下面将详细介绍Scala中的List使用详解。 List类型定义及特点 在Scala中，...
Scala 操作Redis使用连接池工具类RedisUtil
08-25
Scala 操作Redis使用连接池工具类RedisUtil 在 Scala 中操作 Redis 时，连接池工具类 RedisUtil 是非常重要的。下面我们将详细介绍 RedisUtil 的使用方法和实现原理。 首先，我们需要了解什么是 Redis。Redis 是一...
Scala考试题1
08-08
- Scala 使用 REPL（Read-Eval-Print Loop），Java 需要编译。 - Scala 有更强大的模式匹配，Java 需要使用 switch-case 或者 if-else。 15. **Java 集合与 Scala 集合的转换**： - 导入 `scala.jdk....
Scala的安装与使用
zhao
06-05 8680
学习scala前需要先搭建环境，那么怎么安装使用scala呢？ 首先到官网下载scala  ，网址为Scala下载    最新版本为 scala-2.12.6 ，可以下载使用。 本人下载的是scala-2.11.7版本。   --window上使用的话，就下载scala-2.12.6.msi ，然后双击运行，直至安装成功，此时查看环境变量会发现path路径里面已经自动配置了 scala的bin目录...
Scala的基本使用
Yuan_CSDF的博客
04-19 488
1.构造方法的调用 在scala编程语言中，如果创建了某个类的一个实例对象。则这个类中 {}里面的所有的能执行（属性赋值，代码块）的代码都会执行。不能执行的就是： 内部类，方法。如下 1.这里有定义一个构造函数。传入的参数为int1，int2。且这个类只能被在com.my下面class或者object调用。 package com.my private[my] class InputScala(int1:Int,int2:Int) { println(int1) println.
scala的简单使用
yhquser的博客
07-26 172
变量的定义 解释： 定义变量 int和string首字母必须大写 val定义不可变对象（scala一切皆对象） var定义可变对象 下划线为默认值 懒汉定义 解释： 懒汉定义变量（执行的时候才运行） 自动判断值类型 解释： 根据变量的值，自动的去推断数据类型 函数 解释： 函数的定义 函数的调用 表达式中最后一行（图中x和y）表示返回值 选择结构 循环结构 解释： range包头不包尾...
Scala从零开始：使用Scala IDE写hello world
热门推荐
doggggggggggggggggggggggggggggggggggggie的专栏
03-19 4万+
简介 在上一篇文章中，我们阐述了Coursera使用Scala的理由，以及Scala的优缺点。说多不如少练，我们今天就开始练习如何使用Scala编程。 虽然Scala是一门比较新的语言，但是很多机构都为其开发了IDE或者集成插件，比较流行的有Eclipse、IntelliJ以及Netbeans。今天我们使用集成了Scala IDE插件的Eclipse进行代码的编写。 IDE下载及安装
Scala应用场景以及环境部署
OnTheRoad的博客
05-13 1万+
官网：http://www.scala-lang.org/scala介绍Scala即可伸缩的语言（Scalable Language），是一种多范式的编程语言，类似于java的编程 ，设计初衷是要集成面向对象编程和函数式编程的各种特性。Scala的静态类型有助于避免复杂应用程序中的错误，并且其JVM和JavaScript运行时可让您构建高性能系统，并轻松访问图书馆的巨大生态系统。scala应用场景...
一：安装Scala
weixin_33782386的博客
03-26 245
Scala是一种类似Java的纯面向对象的函数式编程语言，由于函数具有明确的确定输入对确定输出的关系，所以适合推理和计算，一切函数都可以看成一系列的计算组成，另外由于Scala函数是没有副作用和透明的，所以非常适合做多核并行计算和云计算，现在正被越来越多的应用到生产中 　　因为Scala运行在JVM上，所以应该首先配置好JDK环境，然后下面是Windows安装Scala环境的过程： 　　1、下...
scala _的用法
haoran_gao的博客
12-28 726
The ones I can think of are Existential typesdef foo(l: List[Option[_]]) = …Higher kinded type parameterscase class A[K[_],T](a: K[T])Ignored variablesval _ = 5Ignored parametersList(1, 2, 3) foreach
scala 中_ 的作用
Dy-修补匠的博客
03-18 471
1、作为“通配符”，类似Java中的*。如import scala.math._ 2、向函数或方法传入可变参数时不能直接传入Range或集合或数组对象，需要使用:_*转换才可传入；:_*作为一个整体，告诉编译器你希望将某个参数当作参数序列处理！例如val s = sum(1 to 5:_*)就是将1 to 5当作参数序列处理。 3、指代一个集合中的每个元素。例如我们要在一个Array a中筛出...
Scala中的下划线到底有多少种应用场景
congliibm的专栏
12-23 1273
我目前了解的有一下几个用处： 1、作为“通配符”，类似Java中的*。如import scala.math._ 2、:_*作为一个整体，告诉编译器你希望将某个参数当作参数序列处理！例如val s = sum(1 to 5:_*)就是将1 to 5当作参数序列处理。 3、指代一个集合中的每个元素。例如我们要在一个Array a中筛出偶数，并乘以2，可以用以下办法： a.fil...
Scala使用for循环生成数组
最新发布
05-31
在Scala中，可以使用for循环生成数组。以下是一个示例： ```scala val arr = for (i ) yield i * 2 ``` 在这个示例中，我们使用了一个for循环来生成一个包含10个元素的数组。`0 until 10`表示从0到9的范围，`yield...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值