Scala简单入门2-CSDN博客

本文链接：https://blog.csdn.net/l_dsj/article/details/121168842

循环、选择结构

import java.util

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

    /**
      * scala中的数据类型
      */
    //基本数据类型
    val byte:Byte = 1
    val short:Short = 1
    val int:Int = 1
    val long:Long = 100
    val float:Float = 1.1F
    val double:Double = 1.2D
    val boolean:Boolean = true
    val char:Char = 'c'

    //Any 好比是Java中的Object
    //AnyRef 是所有引用类型的基类
    //AnyVal 是所有基本类型的基类
    val str:AnyRef = "abc"

    /**
      * 循环
      */
    //while循环计算1-100的和
    var i = 1
    var sum = 0
    while (i<=100){
      sum=sum+i
      i+=1
    }
    println(sum)

    //do while循环计算1-100的和
    var x = 100
    var y = 200
    var x_y = 0
    do{
      x_y = x+y
    } while (x>y)
    println(x_y)

    //for循环
    //实际上scala中的for循环和Python类似，只有for each
    //也有range函数
    //计算1-100的和
    val list = new util.ArrayList[Int]()
    var sum2 = 0
    for (elem <- Range(1, 101, 1)) {
      sum2+=elem
    }
    println(sum2)

    //选择结构
    val age = 18
    if(age>=18){
      println("成年")
    }else if(age<0){
      println("年龄输入不正确")
    }else if(age<18){
      println("未成年")
    }
  }

}

样例类

伴生对象

//object B1和class B1互为伴生对象和伴生类，
//创建对象的时候，可以new一个B1类来创建对象
//也可以用伴生对象的apply方法创建对象或者直接省略，直接创建
val lisi: B1 = B1.apply(“002”,“李四”)
val wangwu: B1 = B1(“003”,“王五”)
B1.fun()

object Demo10Apply {
  def main(args: Array[String]): Unit = {
    val a: A1 = new A1("001","张三")
    val b: B1 = new B1("001","张三")
   }
}

class A1(id:String,name:String){
  val _id:String = id
  val _name:String = name
}

class B1(id:String,name:String){
  val _id:String = id
  val _name:String = name
}

//称之为B1的伴生对象
object B1{
  def fun(): Unit ={
    println("fun")
  }
  //这里会返回一个对象，该对象的类型是跟object同名的一个类
  def apply(id:String,name:String): B1 ={
    val b1 = new B1(id,name)
    b1
  }
}

函数

函数可以定义在Scala中的 类中、object中、函数中

object Demo11Func1 {
  /**
    * 函数可以定义在
    * 类中、object中、函数中
    */
  def fun() ={
    println("fun")
  }
  
  def main(args: Array[String]): Unit = {

    //函数的最后一行代码默认作为返回值
    def fun1(): Unit ={
      println("hello " + fun2())
    }
    
    def fun2(): Unit ={
      "world"
    }
    
  }
}

/**
  * 函数的省略
  * 1、return 关键字可以省略 默认最后一行代码作为返回值
  * 2、返回值类型可以省略 可以根据返回值自动推断
  * 3、只有一行代码的时候 花括号可以省略
  * 4、如果函数没有参数 括号可以省略
  */

def fun3(str:String): Int ={
  return str.toInt + 100
}

//1.函数return关键字可以省略
def fun4(str:String):Int = {
  str.toInt + 100
}

//2.返回值类型可以省略
def fun5(str:String) ={
  str.toInt + 100
}

//3.花括号可以省略
def fun6(str:String) = str.toInt + 100

//4.括号可以省略
def fun7 = "hello world" //这是一个函数

函数式编程

Java中是面向对象编程，是把对象传来传去，对象作为参数传入时会有类型限制，对象作为返回值时也会有类型限制

Scala函数式编程，把函数传来传去，函数作为参数传入时会有类型限制，函数作为返回值时也会有类型限制

有两类，一类是以函数作为参数，一类是以函数作为返回值

函数的类型

什么是函数的类型：
跟def关键字无关
跟函数名无关
跟函数实现的功能无关
跟函数的参数名无关

函数的类型由 参数的类型（类型、个数、顺序）以及返回值的类型共同决定

/**
    * 函数类型
    * @param str
    * @return
    */
  //fun1是一个有一个参数，参数类型为string，返回值类型为int类型的函数
  def fun1(str: String): Int = {
    str.toInt + 100
  }

  //fun2是一个有一个参数，参数类型为string，返回值类型为int类型的函数
  def fun2(str: String): Int = {
    str.toInt + 100
  }

  //fun3是一个有一个参数，参数类型为int，返回值类型为int类型的函数
  def fun3(i: Int): Int = {
    i + 3
  }
  //这里fun1和fun2为同类型函数，fun3不属于

lambda表达式用以简化

/**
    *f:String=>Int
    *f：是funX函数所需要的参数的参数名
    *String=>Int：是funX所需要的参数的类型
    *=> 左边的部分 表示 所传进来的函数 的 参数类型
    *=> 右边的部分 表示 所传进来的函数 的 返回值类型
    */
  //这里定义了一个函数，它可以接收一个函数
  def funX(f:String=>Int) = {
    val i:Int = f("200")
    println(i)
  }


  /**
    * lambda表达式 匿名函数 用以简化函数
   */
  //定义了一个有两个参数 类型分别是string 和 int，返回值类型为int这样的匿名函数
  (str:String,int:Int) => {
    str.toInt + int
  }
  //使用lambda简化fun1
  val i :String => Int =(str:String)=>str.toInt + 100



  def main(args: Array[String]): Unit = {
    println(fun1("200"))
    println(fun2("200"))

    funX(fun1)
    funX(fun2)

    //lambda简化
    funX((str1:String)=>{
      str1.toInt + 1
    })

    //lambda的简化
    //1.如果代码只有一行 花括号可以省略
    //2.参数的类型可以省略 括号也可以顺便省略
    //3.如果参数只被调用了一次，则可以使用_下划线替代
    funX((str1: String) => str1.toInt + 1)
    funX(str1 => str1.toInt + 1)
    funX(_.toInt + 1)
    funX(i)
    println(i("100"))
  }

函数作为参数

这里面函数作为map函数的参数

object Demo13Func3 {
  //函数作为参数的应用
  def main(args: Array[String]): Unit = {
    val array: Array[Int] = Array[Int](1,2,3,4,5,6,7,8)
    println(array) //打印出来一个地址

    //指定一个分隔符，将数组中的元素依次拼接，最后得到一个string
    //同split相反，split是将一个string分割，最后得到一个数组
    println(array.mkString(","))

    //对array中的每个元素加1
    //以函数式编程的思想来做，需要用到map函数，map函数可以对里面的元素做变化
    def add(i:Int):Int = {
      i+1
    }
    array.map(add).foreach(println)
    
//    array.map(_ + 1).foreach(println)
    
  }

}

函数作为返回值

  /**
    * 以函数作为返回值，也有类型的限制
    */
  //在以函数作为返回值时，需要手动给定类型 自动推断会有问题
  //这里定义了一个以函数作为返回值的函数
  def fun1(str1: String):String=>Int={
    def fun2(str2:String):Int={
      str1.toInt + str2.toInt
    }
    fun2
  }

函数柯里化

  //这里定义一个函数，可以传入两个参数
  def fun3(str1:String,str2:String): Int ={
    str1.toInt + str2.toInt
  }

  //函数的柯里化：将一个有N个参数的函数 变成 N个只有一个参数的函数；也就是把括号拆开来罢了
  def fun4(str1:String)(str2:String):Int={
    str1.toInt + str2.toInt
  }

偏函数

  //偏函数：将一个含有N个参数的函数，变成含有N-X个参数的函数 X表示固定的参数；也就是把其中一个变量固定罢了
  //计算a的b次方
  def fun5(a:Int,b:Int = 3):Double = {
    Math.pow(a,b)
  }

感谢阅读，我是啊帅和和，一位大数据专业大四学生，祝你快乐。