Scala 中 " _ " 下划线,底杠 用法较全面收集总结

因本人在用Scala语言中,发现其中 _ 符是个非常神奇又强大的符号,所以收集了一些用法以及实例,内容如下:

1) 调用函数，求方根(导入所有包 )

scala> import scala.math._
scala> sqrt(100)

2)在map中的应用,代表集合中的每一个元素

val listFunc = List("name","age","zhangsan","lisi")
println(listFunc.map(_.toUpperCase()))片

3)通过 _ 将我们的一个方法，转换成函数

 def method3(x:Int,y:String ) :Int = {
  println(x)
  x
}
val methodToFunc = method3 _
println( methodToFunc)

4)访问元组当中的数据直接使用_加角标即可，但是要注意，元组当中的数据角标是从1开始的

val tuple1 = ("hello",1,5.0f)
println(tuple1)

val tuple1Result = tuple1._1
println(tuple1Result)

5)简化二元函数

val reduceList = List(1,2,3,4,5)
//1-2-3-4-5  = -13
val reduceLeftList = reduceList.reduceLeft(_ - _)
//等同于下行代码
val reduceLeftList2 = reduceList.reduceLeft((x,y) => x-y)
println(reduceLeftList)
println(reduceLeftList2)

6)变量只在符号 => 右边出现一次 用 _ 简化

def main(args: Array[String]): Unit = {
  val array  = Array(1,2,3,4,5,6,7,8,9)
  //map当中需要传入一个函数，我们可以直接定义一个函数
  array.map((x:Int) => x * 2 )
  //进一步化简 参数推断省去类型信息
  array.map((x) => x * 2 )
  //进一步化简  单个参数可以省去括号
  array.map( x => x * 2 )
  //进一步化简  如果变量只在=>右边只出现一次，可以用_来代替
  array.map( _ * 2 )

7)柯里化的应用，比较数组集合当中两个对应下标字符串是否相等

def main(args: Array[String]): Unit = {
  val a = Array("Hello", "World")
  val b = Array("hello", "world")
  println(a.corresponds(b)(_.equalsIgnoreCase(_)))
}

8)调用对象的set方法,重新赋值

 def main(args: Array[String]): Unit = {
    //创建对象两种方式。这里都是使用的无参构造来进行创建对象的
    val person = new Person
    val person1 = new Person()
    //注意，我们可以使用对象的属性加上_= 给val修饰的属性进行重新赋值
    //其实就是调用set方法，方法名叫做 age_=    
    person.age_= (50)
    //直接调用类的属性，其实就是调用get方法
    println(person.age)
    println(person.hello(50,"helloworld"))
    val func = person.func1(10,20)
    println(func)
    println("============")
  }

9)自定义对象的set与get方法

class Dog2 {
  private var _leg = 4
//定义get方法,无参,不定义返回值类型,方法体是一个变量,省略括号
  def leg = _leg
//定义set方法
  def leg_=(newLeg: Int) {
    _leg = newLeg
  }
}

object Dog2{
  def main(args: Array[String]): Unit = {
    val dog2 = new Dog2
    dog2.leg_=(10)
    println(dog2.leg)
  }
}


规范提示：自己手动创建变量的getter和setter方法需要遵循以下原则：
1) 字段属性名以“_”作为前缀，如：_leg
2) getter方法定义为：def leg = _leg
3) setter方法定义时，方法名为属性名去掉前缀，并加上后缀，后缀是：“leg_=”，
如例子所示

10)在match中使用

10.1结合if判断,或者匹配所有剩余情况

def main(args: Array[String]): Unit = {
  var ch = "500"
    var sign = 0
    ch match {
      case "+" => sign = 1
      case "-" => sign = 2
      case _ if ch.equals("500") => sign = 3
      case _ => sign = 4
    }
    println(ch + " " + sign)
}

10.2类型匹配

object Test11 {
  def main(args: Array[String]): Unit = {
    //注意泛型擦除，在模式匹配当中的类型匹配中，除了Array类型以为，所有的其他的数据类型都会被擦除掉
    val a = 5

    val obj = if(a == 1) 1
    else if(a == 2) "2"
    else if(a == 3) BigInt(3)
    else if(a == 4) Map("aa" -> 1)
    else if(a == 5) Map(1 -> "aa")
    else if(a == 6) Array(1, 2, 3)
    else if(a == 7) Array("aa", 1)
    else if(a == 8) Array("aa")
    val r1 = obj match {
      case x: Int => x
      case s: String => s.toInt
      case BigInt => -1 //不能这么匹配
      case g: BigInt => Int.MaxValue
      case m: Map[String, Int] => "Map[String, Int]类型的Map集合"
        //其中 _ 表示任意类型,但Map匹配不针对数据类型进行匹配,所以下面的map无用;
      case m: Map[_, _] => "Map集合"
      case a: Array[Int] => "It's an Array[Int]"
      case a: Array[String] => "It's an Array[String]"
      //其中 _ 表示任意类型
      case a: Array[_] => "It's an array of something other than Int"
      case _ => 0
    }
    println(r1 + ", " + r1.getClass.getName)

  }
}

10.3 匹配数组、元组、集合的值的应用

def main(args: Array[String]): Unit = {
  val arr = Array(0, 3, 5)
  arr match {
    case Array(0, x, y) => println(x + " " + y)
    case Array(0) => println("only 0")
      //匹配数组以1 开始作为第一个元素
    case Array(1, _*) => println("0 ...")
    case _ => println("something else")
  }

  val lst = List(3, -1)
  lst match {
    case 0 :: Nil => println("only 0")
    case x :: y :: Nil => println(s"x: $x y: $y")
    case 0 :: tail => println("0 ...")
    case _ => println("something else")
  }

  val tup = (1, 3, 7)
  tup match {
    case (1, x, y) => println(s"1, $x , $y")
    case (_, z, 5) => println(z)
    case  _ => println("else")
  }

}

11）在运算中的应用

 //第一个下划线表示我们累加之后的结果
// 第二个下划线表示我们集合当中每一个元组
// _2  表示元组当中第二个元素
val values: Map[String, Int] = by.mapValues(x => x.foldLeft(0)( _ + _._2))
   for((k,v) <-  values){
      println(k+"====>"+v)
    }

12）给变量赋值

//封装worker信息
class WorkerInfo(val workerId:String,val memory:Int,val cores:Int) {
        //定义一个变量用于存放worker上一次心跳时间
      var lastHeartBeatTime:Long=_

  override def toString: String = {
    s"workerId:$workerId , memory:$memory , cores:$cores"
  }
}

13）隐式转换

object Convert{
  //导入隐式转换的方法
  import Chapter14._
  def main(args: Array[String]): Unit = {
    val first:Int = 3.5
  }
}

以上就是 _ 的用法收集，因本人能力有限，如果有其他用法或者错误，欢迎提出.