Encyclopedia of scala operators

Array A complete collection of array operators

Count array var array:Array[Int]=Array(1,2,3,4,5,6)

One 、 Extract elements

1. array.foreach(f:(a:T)=>Uint) // Traverse == Arguments are passed to the function

array.foreach(println)     =>  1   2    3   4    5    6

2.val rst:Int=array(index)                // Get by index

println(array(1))   =>2

3.val rst:Int=array.apply(index) // Subscript extract element , If you cross the border, you will report an error

println(array.apply(1))    =>2
println(array.apply(6))    =>ERROR：ArrayIndexOutOfBoundsException

4.val rst:Int=array.applyOrElse(index,defalut:(a:Int)=> The body of the function (Any))

// By index index To extract elements , If the index is out of bounds, the function body will be executed , And return the return value of the function

println(array.applyOrElse(1,(a:Int)=>println(s"$a")))   =>2
println(array.applyOrElse(6,(a:Int)=>println(s"$a")))   =>6   ()

5.val rst:Int=array.head     // Get the element at the beginning of the line , If the beginning of a line is empty, an error will be reported NoSuchElementException

   val  rst:Option[Int]=array.headOption    // Get the element at the beginning of the line , According to the function .isEmpty To perform a void judgment ,get Get its value

    val option: Option[Int] = array.headOption
    if (option.isEmpty) {
      println(" Line beginning is empty ")
    }else
      {
        println(option.get)
      }

6.val rst:Int=array.last          // Get the end of line element , If the end of the line is empty, an error will be reported NoSuchElementException

       val  rst:Option[Int]=array.lastOption    // Get the element at the beginning of the line , According to the function .isEmpty To perform a void judgment ,get Get its value

7.val arr:Array[T]=array.slice(start:Int,end:Int)        // Get the elements in the index interval

    val arr: Array[Int] = array.slice(2, 4)
    arr.foreach(println)          ==>3   4

8.val arr:Array[T]=array.take(num:Int)                // Get from left to back num Elements

9.val arr:Array[T]=array.takeRight(num:Int)       // Get... From right to left num Elements

10.val arr:Array[T]=array.takeWhile(f:(a:Int)=>Boolean)       

                // Start from the first number on the left to get the elements that meet the conditions , The first one does not satisfy the requirement of returning null directly , The first number satisfies the condition , Until the end of the first element that does not meet the condition

    array.takeWhile((a:Int)=>a>1).foreach(println)   ==>  empty 
    array.takeWhile((a:Int)=>a<3).foreach(println)   ==> 1  2

11.    val arr:Array[T]=array.filter(f:(a:Int)=>Boolean)                // Extract the elements that meet the conditions

        val arr:Array[T]=array.filterNot(f:(a:Int)=>Boolean)            // Extract elements that do not meet the conditions

    array.filter((a:Int)=>a>3).foreach(println)        ==>  4    5    6
    array.filterNot((a:Int)=>a<=3).foreach(println)    ==>  1    2    3

12.    val arr:Array[T]=array.collect(Predicate:(T)=>Boolean)        // Get the element that satisfies the partial function condition

        val  rst:T=array.collectFist(Predicate:(T)=>Boolean)       // Get the first element that satisfies the partial function condition

    val p:PartialFunction[Int,Int]=(a:Int)=>a match {
            case x if(x%2==0) =>x
            }
    array.collect(p).foreach(println)        ==>  2,4,6
    
== Equivalent to   array.collect({case x if(x%2==0)=>x}).foreach(println)

13.val arr.Array[T]=array.find(f:(T)=>Boolean)                // Get the first element that satisfies the condition   

    array.find((a:Int)=>a>2).foreach(println)   ==>3

14.val arr:Array[T]=array.init                                        // Exclude the last element after each execution

     val arr:Array[T]=array.tail                                        // Exclude the first element after each execution

     val Iterator[Array[T]]=array.inits                             // Exclude other elements of the last element , Encapsulated as an iterator

     val Iterator[Array[T]]=array.tails                              // Exclude other elements of the first element , Encapsulated as an iterator

    array.foreach(print)
    println()        ==>123456
    val init1: Array[Int] = array.init
    init1.foreach(print)
    println()        ==>12345
    val init2: Array[Int] = init1.init
    init2.foreach(print)
    println()        ==>1234

    array.foreach(print)
    println()        ==>123456
    val tail1: Array[Int] = array.tail
    tail1.foreach(print)
    println()        ==>23456
    val tail2: Array[Int] = tail1.tail
    tail2.foreach(print)
    println()        ==>3456
              
    
    val inits: Iterator[Array[Int]] = array.inits
    inits.foreach((a:Array[Int])=>println(a.mkString(",")))
    1,2,3,4,5,6
    1,2,3,4,5
    1,2,3,4
    1,2,3
    1,2
    1        inits.length   ==>7( The last element is empty )

    val tails: Iterator[Array[Int]] = array.tails
    tails.foreach((a:Array[Int])=>println(a.mkString(",")))
    1,2,3,4,5,6
    2,3,4,5,6    
    3,4,5,6
    4,5,6
    5,6
    6        tails.length    ==>7( The last element is empty )

    Two 、 modify

15.    oldArr:Array[T]=array.update(index:Int,t:T)                        // Modify the value under an index in the original array （ The value of the original array changes ）

16.    val newArr:Array[T]=array.updated(index:Int,t:T)                // Modify the value under an index in the array , Return a new array （ The value of the original array remains unchanged ）

17.    val newArr:Array[T]=array.drop(num:Int)                        // Delete from left to right num Data

18.    val  newArr:Array[T]=array.dropRight(num:Int)                // Delete... From right to left num Data

19.     val newArr:Array[T]=array,dropRight(f:(T)=Boolean)        // From left to right , The data satisfying the condition is assigned to the new array

20.     val   newArr:Array[T]=array : +  num[T]                           // Add an element to the right

21.     val  newArr:Array[T]=num[T]   +: array                            // Add an element to the left

22.    val   newArr:Array[T]=array.union(array1)                        //array And array1 Combine

23     val  newArr:Array[T]=array ++ array1                               //array And array1 Combine

24      val   newArr:Array[T]=array.intersect(array1)                  //array And array1 intersection         

25.     val   newArr:Array[T]=array.diff(array1)                           //array And array1 Difference set

26.    val   newArr:Array[T]=array.patch(a:Int,GenSeq(...),num:Int)        // The index of the array is indexed to a Start looking for the element of num individual , Replace with GenSeq The elements inside

    val array=Array(1,2,3,4,5,6,7)
    array.patch(2,GenSeq(9,9,9),2).foreach(print)
        ==> 12999567

        3、 ... and 、 Iterative operator

27.   val newArr:Array[U]=array.map(f: T=>U)                  // Forward processing one by one

28.   val newArr:Array[U]=array.transform(f:  T=>U)         //  Forward processing one by one （ Change the original array ）

29.   val  newArr:Array[U]=array.reverseMap(f: T=>U)      //  Reverse one by one

30.    val  newArr:Array[T]=2Darray,flatten                             // Lower one dimension , flat

31.    val newArr:Array[T]=2Darray.flatMap(t=>t.map(..))        // First lower one dimension , Each element is processed

    array.map(a => a+2).foreach(print)          ==> 3456789
    array.foreach(print)                        ==> 1234567
    array.transform(a=>a+2).foreach(print)      ==> 3456789 
    array.foreach(print)                        ==> 3456789
    array.reverseMap(a=>a+2).foreach(print)     ==> 111098765

    val arr=Array(Array(1,2,3),Array(4,5,6))
    arr.flatten.foreach(print)                  ==> 123456

        Four . grouping

32.        val  newArr:Array[T]=array.par                                        // Parallel array processing , It is often used to start the thread to process , With the method aggregate In combination with

33.        val tp2:(Array[T],Array[T])=array.partititon(t:T=>Boolean)        // Divide the elements in the array into two arrays , Form a tuple , Those that meet the conditions are in a group , Two groups that do not meet the conditions

34.        val it:Interator[Array[T]]=array.grouped(num)                   // Divide the array into num An array

35.        val map:Map[Int,Array[T]]=array,groupBy(key:B)                // Press... In the array key Grouping (T Pairs are tuples or spline classes ), Form key value pairs

36.        val it:Interator[Array[T]]=array.sliding(size:Int,step:Int)       // By each group of elements size individual , Every step step Regroup elements    1,2,3   2,3,4  3,4,5

    array.par.foreach(print);println()            ==>  165432
    val tp1: (Array[Int], Array[Int]) = array.partition(a => a > 3)
    tp1._1.foreach(print);println()               ==>  456
    tp1._2.foreach(print);println()               ==>  123
    val tp2: Iterator[Array[Int]] = array.grouped(3)
    for (elem <- tp2) {elem.foreach(print);println()}   ==> 123   456


    val arr=Array((1,"a"),(1,"b"),(2,"a"))
    val map: Map[Int, Array[(Int, String)]] = arr.groupBy(_._1)
    map.map(a=>{print(a._1);a._2.foreach(print);println()})    
                        ==>2(2,a)     1(1,a)(1,b)
    map.map(a=>println(a._1,a._2.count(a=>true)))    ==>(2,1)     (1,2)