Scala学习第二天

最新推荐文章于 2024-03-02 16:38:25 发布

haibei153

最新推荐文章于 2024-03-02 16:38:25 发布

阅读量97

点赞数

本文链接：https://blog.csdn.net/haibei153/article/details/119704728

版权

方法

定义方法的基本语法

def methName(参数名：参数类型，参数名：参数类型) ：{return type}={
//f方法体
}

说明：1.在定义参数时参数类型不能省略

2.返回值类型可以省略，由Scala编译器自动推断

3.返回值可以不写return，默认是{}块表达式的值

4 在递归方法中不能省略返回值类型

//普通方法 
def add (a03:Int,b03:Int) = {
     a03+b03
    }
    var c=add(55,10)
    println(c)
    println(add(55,10))


def add01(a04: String, b04: String) = {
      val c = a04 + b04
      c
    }

    var cc = add01("hello", "Scala")
    println(cc)
    println(add01("hello", "  Scala"))


//递归方法   需要声明返回值类型
    def daa(a05: Int, b05: Int) :Int={
      val s = a05 + b05
      if (a05 > 0) {
        daa(a05 - 1, b05 - 1)
      }
      return s
    }

    println(daa(50, 10))

方法参数：

   变长参数：如果方法类型不固定，可以定义方法参数是变长参数
   在参数类型后面加上  *  号，表示参数可以是0个或者多个

默认参数：在定义方法时可以给参数定义一个默认值
带名参数：在调用方法时，可以指定参数名称来进行调用

//变长参数
def add05(num:Int*)={
      num.sum
    }
    println(add05(1,5,3,6,9,6,3,5,3,6,7))
    println(add05())
//默认参数
    def add06(i:Int=0,j:Double=0.0):Double={
      return i+j
    }
    println(add06(5,6.0))
    println(add06())
//带名参数
  def add06(i:Int=0,j:Double=0.0):Double={
      return i+j
    }
    println(add06(i=6))

方法的调用方式

后缀调用法和Java相同
中缀调用法语法：对象名方法名参数
中缀调用法引申：操作符即方法 1+1 （类似于中缀调用法）
（在Scala中，+-*/% 这些操作符和java一样，但在Scala中
所有的操作符都是方法，操作符是一个方法名字。是符号的方法）
花括号调用法使用块表达式的返回值 =方法的参数（方法参数只有一个时，才使用花括号调用法）
无括号调用法如果方法没有参数，可以省略方法名后面的括号

//后缀调用法
   val a10= Math.abs(-1)
    println(a10)

//    中缀调用法
    1 to 10
   val a11= Math abs -1
    println(a11)


//    操作符即方法
    1 + 1


//    花括号调用法
    Math.abs{
      println("求绝对值")
      -1
    }

//    无括号调用法
    def printHello(): Unit ={
      println("hello")
    }
    println(printHello)

函数

语法：val 函数变量名=（参数名：参数类型，参数名：参数类型）=>函数体
函数是一个对象
有输入参数和返回值
函数定义不需要使用def 定义
无需指定返回值类型

方法和函数的区别：（函数是一个对象，而方法不是一个对象）

方法是隶属于类和对象的，在运行时，它是加载到JVM的方法方法区中
可以将函数对象赋值给一个变量，在运行时加载到JVM中堆内存中
函数是一个对象，继承于FunctionN,函数对象有apply，curried，toString,tupled这些方法，方法则没有

方法转化成一个函数

有时候需要将方法转化成函数，作为变量的传递
使用_即可将方法转化成函数

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

    def add12(x:Int,y:Int):Int=x+y
    val aa15 =add12     //说明：方法不能赋值给变量
    var bb15 =add11
    println(aa15)
    println(bb15)




//将方法转化成一个函数

 def add12(x:Int,y:Int):Int=x+y
    val aa15 =add12        //说明：方法不能赋值给变量
    val aa15 =add12 _      //可以将方法转换成一个函数，从而可以达到给方法赋值的效果
    var bb15 =add11
    println(aa15)
    println(bb15)

数组

定长数组：
定长数组指的是数组长度是不可以被改变的，而数组的元素是可以被改变的
定义数组的语法：通过指定长度定义数组 val/var 变量名=new Array[元素类型] (数组长度)
用元素直接初始化数组： val/var 变量名 = Array(元素1，元素2，元素3，元素4，。。。。)
说明：在scala中使用（）来获取元素，泛型使用[]来指定

val a= new Array[Int](100)   //表示我们要创建一个整形数组，长度为100
    a(0)=110                     //设置第一个元素110,在Scala中指定元素使用括号
    println(a(0))
    println(a(1))


//查看数组
  val a19=Array("1","2",3)
   println( a19(2))

//修改数组
a19(0)="aa"

变长数组：变长数组指的是数组的长度是可变的，可以往数组中添加，删除元素

创建变长数组，需要提前导入ArrayBuffer类 import scala.collection.mutable.ArrayBuffer
语法：创建空的ArrayBuffer变长数组：
语法结构：
val/var a=ArrayBuffer[元素类型]（）
创建带有初始化元素的ArrayBuffer val/var a=ArrayBuffer(元素1，元素2，元素3)
添加，修改，删除元素
使用+=添加元素：添加
使用-=删除元素：删除
使用++= 追加一个数组到变长数组

//创建变长数组
//创建方式一
 val a20=ArrayBuffer[Int]()
    a20(0)=120

//创建方式二
 val a21=ArrayBuffer(1,2,3,4,5,6,"aaa")


//添加、修改，删除元素

 //添加
 a21+="bbb"
 //ArrayBuffer(1, 2, 3, 4, 5, 6, aaa, bbb)

 //删除
 a21-="aaa"
 println(a21)
 //ArrayBuffer(1, 2, 3, 4, 5, 6, bbb)

 //添加一个数组
 val a19=Array("1","2",3)
 println( a19(2))
 a21++=a19
 println(a21)
//ArrayBuffer(1, 2, 3, 4, 5, 6, bbb, 1, 2, 3)


//修改数组
    a21(5)="ss"
    println(a21)
//ArrayBuffer(1, 2, 3, 4, 5, ss, bbb, 1, 2, 3)

遍历数组：

//   遍历数组
    val a22 =Array(1,2,3,4,5,6,7,8,9)
    for (i<- a22){
      println(i)
    }

//    使用for表达式基于索引下标遍历，并打印数组的元素
    for(i<- 0 to a22.length-1){
      println(a22(i))
    }
    
//    使用until   (和to的区别在于 until不会包含 a.length最后一个值)
    for(i<- 0 until  a22.length)  println(a22(i))

数组的常用算法：

   val a24=ArrayBuffer(1,2,3,4,5,6,7,8,9)
//    求和
    println(a24.sum)
//    求最大值
    println(a24.max)
//    求最小值
    println(a24.min)
//    排序
    a24+=15
    a24+=16
    a24+=8
    a24+=35
    println(a24.sorted)//升序排序
    println(a24.reverse)//降序排序

引入集合的原因：数组的长度的不可变型，和元素数据类型的单一型，造就了各样的集合

元组：（值是不可以被改变的）

定义元组，访问元组

 //    元组
    //    定义元组
    //            语法：使用括号定义元组
    val a25 = ("1", "2", "3", "4", "5")
    val a26 = "1" -> "2" -> "3"
//    访问元组
    val a27 ="zhangsan"->"25"->"male"
    println(a27._1)
    println(a27._2)

列表

不可变列表：（数据结构类似于Scala中的数组）

//   不可变 列表   长度不可变
//    使用List（元素1，元素2，元素3，。。。）来创建一个不可变列表，语法格式
    val a28=List(1,2,3,4,5,6)
    val a29=Nil   //创建一个空列表
    val a30=1::2::3::4::Nil     //记得加Nil
    println(a28)
    println(a29)
    println(a30)

可变列表：（类似于Scala可变数组）

//    可变列表   需要导入ListBuffer
//    可变集合都是在  mutable中，而不可变集合是在 immutable中
//    可变列表的定义  ：  使用ListBuffer[元素类型]()创建空的可变列表
//                 使用  ListBuffer(元素1，元素2，元素3)  创建可变列表
    //定义
    val a31=ListBuffer[Int]();
    val a32=ListBuffer(1,2,3,"aa","cc")


    //可变列表的操作
    a32(3)     //获取元素：使用括号访问（索引值）
    println(a32)
    a32+=3    //添加操作
    println(a32)
    a32-="aa"   //删除操作
    println(a32)
    a32(3)="bb"  //修改操作

    a31+=1      //添加一个列表
    a32++=a31
    println(a32)

    val a33=a32.toList
    println(a33)      //转换为List

    val a34=a32.toArray  //转换为Array
    println(a34)

haibei153

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Scala学习第二天

方法定义方法的基本语法def methName(参数名：参数类型，参数名：参数类型) ：{return type}={ //f方法体 }说明：1.在定义参数时参数类型不能省略 2.返回值类型可以省略，由Scala编译器自动推断 3.返回值可以不写return，默认是{}块表达式的值 4 在递归方法中不能省略返回值类型//普通方法 def add (a03:Int,b03:Int) = { a...
复制链接

扫一扫