Scala编程基础((超级详细版)

最新推荐文章于 2024-08-05 20:09:54 发布

难以触及的高度

最新推荐文章于 2024-08-05 20:09:54 发布

阅读量1.1k

点赞数 31

文章标签： scala 开发语言后端

本文链接：https://blog.csdn.net/2301_77836489/article/details/139145354

版权

Scala编程基础

Scala：简洁优雅，函数式编程之美。

今天的目录有点长

说在前面

在Scala中任何数据都是对象

在Scala中所有的算数运算符都是方法

1.Scala创建类

Scala中将动态方法和静态方法分开了

Class类：放动态方法

Object类：放静态方法（static 比如main函数）

2.Scala定义变量

package com.oracle.jt
/**
 * Object中类方法都是静态的
 */
object Test {
  def main(args: Array[String]): Unit = {
    print("山东人民万岁！")

    //定义变量的格式：[val|var] 变量名[:数据类型]=值;
    //scala能自己识别数据类型
    val a=23
    val b="ff"
    val c:String="33";

    var d="wangwu";
    var e=33.333
    //var val区别：val不能重新赋值
    d="wangfeng" //var可以重新赋值 是真正的变量
    print(a,b,c,d,e)
  }
}

3.val与var区别（考试）

val变量值不能更改不能重新赋值 var变量的值可以更改

4.scala数据类型（考试）

Scala 和 Java 一样，有7种数值类型 Byte、char、Short、Int、Long、Float 和 Double(无包

装类型)和一个 Boolean 类型。没有包装类

package com.oracle.jt

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

    val v1:Int=23;
    val v2:Float=34.5f;
    val v3:Double=34.8d;
    val v4:Long=23;
    val v5:Short=23;
    val v6:Byte=23;
    val v7:Char='f'
    val v8:Boolean=true
    print(v1,v2,v3,v4,v5,v6,v7,v8)

  }

}

5.Scala条件表达式（选择题）

条件表达式：
在给一个变量赋值的时候 大家有没有见到过一个变量的取值
在不同的条件下 变量的值是不一样的
如果结果不符合条件表达式那么控制台将输出 ( )

package com.oracle.jt

object Test3 {
  def main(args: Array[String]): Unit = {
    //条件表达式：
    //在给一个变量赋值的时候 大家有没有见到过一个变量的取值
    //在不同的条件下 变量的值是不一样的

    var b=23
    var a=if(b>20) 56 else 90;
    println(a)

    val c=if(b>50) 90
    print(c)
    //如果不符合条件 打印括号（）
  }
}

package com.oracle.jt

object Test3 {
  def main(args: Array[String]): Unit = {
    //条件表达式：
    //在给一个变量赋值的时候 大家有没有见到过一个变量的取值
    //在不同的条件下 变量的值是不一样的

    val str="aa"
    val f=if(str.equals("aa")) "fff" else "sss"
    print(f)
    //如果不符合条件 打印括号（）
  }
}

package com.oracle.jt

object Test3 {
  def main(args: Array[String]): Unit = {
    //条件表达式：
    //在给一个变量赋值的时候 大家有没有见到过一个变量的取值
    //在不同的条件下 变量的值是不一样的

    val a=2;
    val b=3;
    val c=if(a+b==5) 66 else 99;
    print(c)
    //如果不符合条件 打印括号（）
  }
}

6.块表达式

在Scala中最后一行变量是用来赋值或者当作返回值的

package com.oracle.jt

object Test4 {
  def main(args: Array[String]): Unit = {
    val a={
      //print(0.to(10).toBuffer)
      var b=0
      //求0-10的累加和
      for(a <- 0.to(10))
        {
          b=b+a
        }
        b // b放在for循环外 表示把b的值赋给a
    } //{} 块
    print(a)
  }

}

7.循环

Scala中 for循环是用来遍历集合的

后面只能跟集合

Java中for循环是用来控制循环次数的

package com.oracle.jt

object Test6 {
  def main(args: Array[String]): Unit = {
    var a=Array(3,4,5,6,7)//Array()就是Java的数组
    //for(变量名<-集合){}
    for(elm<-a)
      {
        println(elm)
      }
  }

}

在Scala中任何数据都是对象

//如果我想Java那样用for循环生成一串数字 那就只能使用下面的方法
      //var b=Array(0,1,2,3,4,5,6,7,8,9)

      var b1=0.until(10) //产生左闭右开的区间数字
      var b2=0.to(10) //产生闭开区间数字
      print(b1)
      println(b2)

1）练习（菜就多练）：

求1-100累加和求1-100偶数和

package com.oracle.jt

object Test7 {
  def main(args: Array[String]): Unit = {
    val sum= {
      var s=0
      var s1=0
      for(sum<-0.to(100)){
        s=s+sum
      }
      s
    }
    println(sum)


    val sum2={
      var s= 0
      for(sum2<-0.to(100)){
        if(sum2%2==0) s=s+sum2 else s=s+0
      }
      s
    }
    print(sum2)

  }

}

2）代码改进

package com.oracle.jt

object Test7 {
  def main(args: Array[String]): Unit = {
    val sum= {
      var s=0
      var s1=0
      for(sum<-0.to(100)){
        s=s+sum
      }
      s
    }
    println("1-100的累加和为："+sum)


    val sum2={
      var s= 0
      for(sum2<-0.to(100)){
        if(sum2%2==0) s=s+sum2 else s=s+0
      }
      s
    }
    println("1-100的偶数和为："+sum2)

    val sum3={
      var s= 0
      for(sum3<-0.to(100)){
        if(sum3%2==1) s=s+sum3 else s=s+0
      }
      s
    }
    print("1-100的奇数和为："+sum3)
  }
}

3）for循环中加判断条件

在for循环中我们可以加判断条件这样的话对于求偶数和就变得更简单了

package com.oracle.jt

object Test8 {
  def main(args: Array[String]): Unit = {
    val a=1.to(10)
    var b=0
    for(elm <- a;if(elm%2==0)){
      b=b+elm
      println(elm)
    }
    print(b)
  }
}

8.Scala函数式编程（核心）

在Scala中所有的算数运算符都是方法

package com.oracle.jt

object Test9 {
  def main(args: Array[String]): Unit = {
    val a=22
    val b=13
    val c=a.+(b)
    val d=a.*(b)
    val e=a./(b)
    val f=a.-(b)
    val g=a.%(b)
    print(c,d,e,f,g)
  }

}

1）Scala定义方法

package com.oracle.jt

object Test10 {
  //Scala定义方法的格式

  /**
   * def 方法名 (a:数据类型,b:数据类型....) [={}]
   * []表示可以省略
   * 关于大括号 如果就一行代码 大括号可以省略
   * 关于等号 如果没有返回值 可以省略
   */

      // 一行代码 可以省略 {}
    def add()=
      println("山东人民万岁")

  //有参数 无返回值 可以省略 = 
  def add(a:Int,b:Double){
    val c=a+b
    println(c)
  }
  //有返回值 写 =
  def add(a:Int,b:Double,c:Int)={
    val d=a+b+c
    if(d>0) d else 13
  }

  def main(args: Array[String]): Unit = {
    add() //静态方法可以直接调用
    add(12,34.7)
    val res=add(12,34.6,78) //有返回值 接收一下
    print(res)
  }

}

①注意:

//有返回值 写 =
def add(a:Int,b:Double,c:Int): Unit={
  val d=a+b+c
  if(d>0) d else 13
}

//有返回值 写 =
def add(a:Int,b:Double,c:Int)={
  val d=a+b+c
  if(d>0) d else 13
}

②练习1

在主方法中传递一个带 , 的字符串给普通方法普通方法返回以 , 为分隔符之后的数组

在主方法中打印数组中的每个元素

package com.oracle.jt

object Test11 {
  def main(args: Array[String]): Unit = {
    val s="jhw,yyq"
    val res=splt(s)
    for(elm <- res){
      println(elm)
    }

  }
  def splt(s:String):Array[String]={
      val res=s.split(",")
      res
  }

}

③练习2

在主方法中创建A对象为A的对象赋值传递A对象给普通方法在普通方法中打印A对象中的值

package com.oracle.jt

class A {
  private var Sname: String=_;
  private var Ssex: String = _;
  def getSname():String=Sname
  def setSname(name:String):String=
    {
      Sname=name
      Sname //返回姓名值
    }
  def getSsex():String=Ssex
  def setSsex(sex:String):String=
    {
      Ssex=sex
      Ssex //返回性别值
    }
}


package com.oracle.jt

object Test12 {
  def prt(a:A)={
    val name=a.getSname()
    val sex=a.getSsex()
    println(name)
    println(sex)
  }
  def main(args: Array[String]): Unit = {
    val a=new A
    a.setSname("jhw")
    a.setSsex("nan")
    prt(a)
  }
}

2）Scala定义函数

①重要思想

目标：

1.学会定义函数（思想：函数是变量函数是方法）

val 函数名=(a:参数类型,b:参数类型....)=>{代码块返回值}

2.学会调用函数

函数名(参数值1,参数值2....)

为什么说Scala的一行代码抵得上Java的很多行代码？

因为Scala的代码都已经以函数的形式写好了

可以直接调用使用

效果如下：

package com.oracle.jt

object Test13 {
  //函数的定义：val 函数名=(a:参数类型,b:参数类型....)=>{代码块 返回值}
  val add=(a:Int,b:Int)=>a+b

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

    //函数的调用：函数名(参数值1,参数值2....)
    val d=add(13,45)
    println(d)
  }
}

②练习：

用函数实现下面的需求：

在主方法中传递一个带 , 的字符串给普通方法普通方法返回以 , 为分隔符之后的数组

在主方法中打印数组中的每个元素

package com.oracle.jt

object Test14 {
  val splitString=(s:String)=>{
    val res:Array[String]=s.split(",")
    for(elm<-res){
      println(elm)
    }
  }
  def main(args: Array[String]): Unit = {
       var s="a,b,c,d,e"
      splitString(s)
  }
}

③函数的声明及调用

package com.oracle.jt

object Test13 {
  //函数的定义：val 函数名=(a:参数类型,b:参数类型....)=>{代码块 返回值}
  //val fun=(a:String,b:String,c:String)=>a+b+c
  //val add=(a:Int,b:Int)=>a+b
  //函数是变量 现在把它传递给一个方法
  //函数声明：把函数实现变为参数类型和返回值类型 然后起个名字就可以了
  def myAdd(f:(Int,Int)=>Int): Int ={
    //声明以后我们就可以调用了
    val res=f(12,23)
    res
    //直接写f(12,23)也没错 Scala简洁
  }
  def strconat(s:(String,String,String)=>String):String={
    val a="你"
    val b="好"
    val c="坏"
    s(a,b,c)
  }

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

    //函数的调用：函数名(参数值1,参数值2....)
    //val d=add(13,45)
    //println(d)

    //函数的实现
    val res1=myAdd((a:Int,b:Int)=>a+b) //方法右返回值 接收一下
    //val res1=myAdd(add)
    println(res1)

    val res2=strconat((a:String,b:String,c:String)=>a+b+c)
    //val res2=strconat(fun)
    println(res2)
  }
}

练习：写出 a-b 的函数式编程（使用函数的声明和实现）

package com.oracle.jt

object Test15 {

  def mySub(f:(Int,Int)=>Int)={
    val a=12;
    val b=23;
    f(a,b)
  }
  def main(args: Array[String]): Unit = {

    val res = mySub((a: Int, b: Int) => a + b)
    print(res)
  }

}

④练习：

定义一个方法包括一个参数参数类型是函数

函数有两个参数 Int String

返回Int和String的拼接

在主方法中调用方法并传递函数实现

package com.oracle.jt

object Test16 {
  def strAdd(f:(Int,String)=>String)={
    f(521,"一生一世")
//    val a=521
//    val b="一生一世"
//    a+b
  }
  def intAdd(f:(Int,String)=>Int)={
    val a=521
    val b="一生一世"
    a+b
  }
  def main(args: Array[String]): Unit = {
    val res1=strAdd((a:Int,b:String)=>a+b)
    println(res1)

    val res2=strAdd((a:Int,b:String)=>a+b)
    print(res2)
  }

}

package com.oracle.jt

object Test17 {
  def splitStr(f:(String)=>Array[String])={
    f("a,c,d,e")
  }
  def main(args: Array[String]): Unit = {
    //在实现的时候 我们可以不写类型
    val res=splitStr((f:String)=>f.split(","))
    for(elm<-res){
      println(elm)
    }
    val array=Array[String]("a,b","c,d","e,f")
    val a = array.map(s => s.split(","))
    println(a.toBuffer)

  }
}

⑤Scala中map用法

map是用来对数组中的每个元素做一对一类型转换的
array.map的参数是String 返回值可以是任何类型

我们可以自己定义一下map的内容

package com.oracle.jt

import scala.collection.mutable.ArrayBuffer

class ArrayDemo {
  val array=new ArrayBuffer[String]()
  def add(s:String): Unit ={
    array.append(s)
  }
  def map(f:(String => Array[String])): ArrayBuffer[Array[String]] ={
    val cvtArray=new ArrayBuffer[Array[String]]()
    for (elm<-array){
      cvtArray.append(f(elm))
    }
    cvtArray
  }

}


package com.oracle.jt

object Test20 {
  def main(args: Array[String]): Unit = {
    val array=new ArrayDemo()
    array.add("a,d")
    array.add("c,e")
    array.add("g,h")
    val res=array.map(x=>x.split(","))
    println(res)
  }

}

我们也可以直接用因为Scala已经给我们写好了

 val array1=new ArrayBuffer[String]()
    array1.append("1,2")
    array1.append("3,5")
    array1.append("3,5")
    val res1 = array1.map(s => s.split(","))
    println(res1)

3）方法转化为函数

package com.oracle.jt

object Test21 {
  def add(a:Int,b:Int)=a+b
  def main(args: Array[String]): Unit = {
    //把方法转换成函数
    val fun=add _
    val res=fun(213,456)
    println(res)
  }

}