[Scala]006-遇到的懵圈特殊符号组合-解释大全

你的名字 2022-02-03 06:39 122阅读 0赞

特殊符号无非就这些：`` `、~、@、#、$、%、^、&、*、-、=、{、[、;、:、|、<、/、?``等这些。

简直是令人发指啊！  
不过谁让Scala大数据必备语言呢，嗯，还优雅，哈哈。  
用用就习惯它的风格了。

用的最多的是：`-+=:_<>/` 进行组合！！

1、`+=`、`-=`  
`+=`：为可变数组添加元素、为map添加新的值  
`-=`： 为可变数组减去元素、为map移除相应的值

scala> var s:String = "a"
    s: String = a
    
    scala> s += "b"
    
    scala> s
    res1: String = ab
    
    scala> s ++= "c"
    
    scala> s
    res3: String = abc
    
    scala> var a = Map(1->2,2->3)
    a: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 2 -> 3)
    
    scala> a += (3->4)
    
    scala> a
    res6: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 2 -> 3, 3 -> 4)
    
    scala> a -= (3)
    
    scala> a
    res10: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 2 -> 3)

2、`::`（构造列表）两个冒号：表示普通元素与list的连接操作

*  用法为`x::list`,其中x为加入到头部的元素，无论x是列表与否，它都只将成为新生成列表的第一个元素，也就是说新生成的列表长度为list的长度＋1
 *  `x::list`等价于`list.::(x)`
 *  `:::`方法：只能用于连接两个List类型的集合

3、`:+`和+:(列表追加元素)

*  `:+`方法：用于在尾部追加元素
 *  `+:`方法：用于在头部追加元素
 *  只要记住冒号永远靠近集合类型

scala> List(1,2,3)
    res14: List[Int] = List(1, 2, 3)
    
    scala> res14:+2
    res15: List[Int] = List(1, 2, 3, 2)
    
    scala> 3+:res14
    res16: List[Int] = List(3, 1, 2, 3)

4、`++`(连接两个Seq)

*  列表、集合、字符串、Map
 *  `:::`方法：只能用于连接两个List类型的集合

scala> val a = List(1,2,3)
    a: List[Int] = List(1, 2, 3)
    
    scala> a++List(4,5,6)
    res17: List[Int] = List(1, 2, 3, 4, 5, 6)

5、`<-`（遍历集合）

scala> var arr = Array(1,2,3,4)
    arr: Array[Int] = Array(1, 2, 3, 4)
    
    scala> for (i <- arr) {
         |    println(i)
         | }
    1
    2
    3
    4

6、`->`（返回一个二元元组Tuple）

scala> var a = List(1,2,3)
    a: List[Int] = List(1, 2, 3)
    
    scala> var b = List(4,5,6)
    b: List[Int] = List(4, 5, 6)
    
    scala> a -> b
    res19: (List[Int], List[Int]) = (List(1, 2, 3),List(4, 5, 6))

7、`=>`（匿名函数）  
匿名函数定义：

(形参列表) => {函数体}

*  左边的参数 到 右边的函数体，比如：(x:Int) => x+1
 *  可以有一个变量接收

8、`_`下划线

*  通配符
 *  访问元组。`_N`访问元组第N个元素

scala> val tup = (1,2,3)
    tup: (Int, Int, Int) = (1,2,3)
    
    scala> tup._1
    res20: Int = 1

*  将方法转换成函数
    
     *  `val f1 = m _`
     *  在方法名称m后面紧跟一个空格和下划线告诉编译器将方法m转换成函数，而不是要调用这个方法
 *  递归调用：把里面每个元素提取出来。`：_*` 作为一个整体，告诉编译器你希望将某个参数当做数序列处理

def main(args: Array[String]): Unit = {
        val s = sum(1 to 5:_*)      //把1 to 5当作一个序列处理
        println(s)
    }
    
    def sum(args: Int*) : Int = {
        var result = 0 ;
        for(s2 <- args) {
          result += s2 ;
        }
        result ;
    }

*  指代集合中的每个元素

scala> var list = List(1,2,3,4)
    list: List[Int] = List(1, 2, 3, 4)
    
    scala> list.map(_*2)
    res23: List[Int] = List(2, 4, 6, 8)

*  代表某一类型的默认值
    
     *  加不加空格都可以
     *  对于Int类型来说，它是0
     *  对于Double来说，它是0.0
     *  对于引用类型来说，它是null

scala> var a:Int = _
    a: Int = 0
    
    scala> var a:Float = _
    a: Float = 0.0

9、`/:` ，`:\`  
`/:` 与 `:\` 分别对应 foldLeft 和 foldRight 函数，是它们的缩写。详解：

scala> val a = List(1,2,3,4)
    a: List[Int] = List(1, 2, 3, 4)
    
    scala> def ss(x: List[Int]): (Int, Int, Int) = x./:((0,0,0))((t,v) => (t._1 +2,t._2+v,t._3+v*v))
    ss: (x: List[Int])(Int, Int, Int)
    
    scala> ss(a)
    res25: (Int, Int, Int) = (8,10,30)

> 注：`x./:((0, 0, 0))((t, v) => (t._1 + 2, t._2 + v, t._3 + v * v))` 表示对集合 `x` 进行循环，其中 `(0,0,0)` 代表函数 `(t._1 + 2, t._2 + v, t._3 + v * v)` 的初始值，`t` 作为一个记录结果的值，而 `v` 代表每次传进来的集合 `x` 的值

第一次循环：0+2,0+1,0+1  
第二次循环：2+2,1+2,1+4  
第三次循环：4+2,3+3,5+9  
第四次循环：6+2,6+4,14+16

10、`<:`、`>:`  
这属于Scala泛型中的知识：上边界和下边界。上边界是`<:`，下边界是`>:`