Scala数组、集合函数大全A-N

NeilVicia

已于 2022-06-19 22:28:17 修改

阅读量851

点赞数 1

文章标签： scala java 开发语言

于 2021-12-13 23:26:16 首次发布

本文链接：https://blog.csdn.net/liuyongsheng666/article/details/121916748

版权

++ ++： +：：+ /: :\

package test

object demo1 {
  def main(args: Array[String]): Unit = {
    val arr=Array(1,2,3,4)
    val first=arr(0)
    arr(3)=100
    val newarr=arr.map(_ *2)
    println(first)
    println(newarr.mkString(","))



    val a=List(1,2)
    val b=scala.collection.mutable.LinkedList(3,4)
    val c=a++:b
    val d=b++:a

    val e=a++b
    val f=b++a

    println(e)
    println(f)
    println(c)
    println(d)

    println(c.getClass().getName())


    val g=List(1,2)
    val h=0 +:g
    println(h.mkString(","))


    

  }

}

package test

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

    val a=List(1,2,3,4)
    val b=(10/:a)(_+_)

    println(b)


    val c=List(1,2,3,4)
    val d=(c :\ 10)(_-_)
    println(d)





  }

}

ACFunctionTest

package test

import scala.collection.mutable.ArrayBuffer

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

    //apply 获取指定索引处的元素
    val a=List(1,10,100,100)
    val b=a.apply(1)
    println(b) //10

//    val a1=List(1,2,3,4)
//    val b1=new StringBuilder()
//    a1.addString(b1)
//    println(b1)
//
//
//    val a2=List(1,2,3,4)
//    val b2=new StringBuilder()
//    a2.addString(b2,"-")
//    println(b2)


    //canEqual 判断两个对象是否可以进行比较
    val a1=List(1,2,3,4)
    val b1=Array('a','b','c')
    println(a1.canEqual(b1))  //true


    //charAt 获取 index 索引处的字符，这个方法会执行一个隐式的转换，
    // 将 Array[T] 转换为 ArrayCharSequence，只有当 T 为 Char 类型时，这个转换才会发生
    val chars = Array('a', 'b', 'c')
    println(chars.charAt(0)) // a


    //clone  创建一个副本
    val a2 = Array(1, 2, 3, 4)
    val b2 = a2.clone()
    println(b2.mkString(",")) // 1,2,3,4


    //collect  偏函数 通过执行一个并行计算（偏函数），得到一个新的数组对象
    val fun1: PartialFunction[Char, Char] = {
      case 'a' => 'A'
      case x => x
    }
    val a3 = Array('a', 'b', 'c')
    val b3 = a3.collect(fun1)
    println(b3.mkString(",")) // A,b,c

    //collectFirst   查找第一符合偏函数定义的元素 执行偏函数计算
    val fun2:PartialFunction[Any,Int]={
      case x:Int=>x*100
    }
    val a4=Array(3,1,'a',"b")
    val b4=a4.collectFirst(fun2)

    println(b4)  //Some(300)

//    b = arr.collectFirst({ case x: Int => x * 100 })

    //combinations combinations 表示组合，这个排列组合会选出所有包含字符不一样的组合，
    // 但不考虑顺序，对于 “abc”、“cba”，视为相同组合，
    // 参数 n 表示序列长度，就是几个字符为一组
    val a5=Array("a","b","c","d")
    val b5=a5.combinations(2)
    b5.foreach(x=> println(x.mkString(",")))   //foreach遍历
    //a,b
    //a,c
    //a,d
    //b,c
    //b,d
    //c,d


    //contains 判断序列中是否包含指定对象
    val a6=List(1,2,3,4)
    println(a.contains(1)) //true


    //containsSilce 判断当前序列中是否包含另一个序列
    val a7=List(1,2,3,4)
    val b6=List(3.2)
    val b7=List(2,3)
    println(a7.containsSlice(b6))  //false
    println(a7.containsSlice(b7))  //true

    //copyToArray(xs) 将当前数组元素复制到另一个数组中
    val a8=Array(1,2,3)
    val b8:Array[Int]=new Array(5)
    println(b8.mkString(","))
    a8.copyToArray(b8)
    println(b8.mkString(","))
    //0,0,0,0,0
    //1,2,3,0,0

    //copyToArray(xs, start) 将当前数组元素复制到另一个数组中，从 start 位置开始复制
    val a9=Array(1,2,3)
    val b9:Array[Int]=new Array(7)
    a9.copyToArray(b9,3)
    println(b9.mkString(","))
    //0,0,0,1,2,3,0

    //copyToArray(xs, start, len) 将当前数组元素复制到另一个数组中，从 start 位置开始复制，长度为 len
    val a10=Array(1,2,3)
    val b10:Array[Int]=new Array(10)
    a10.copyToArray(b10,1,2)
    println(b10.mkString(",")) //0,1,2,0,0,0,0,0,0,0

    //copyToBuffer 将数组中的元素复制到 Buffer 中
    val a11 = Array(1, 2, 3, 4)
    val b11: ArrayBuffer[Int]=ArrayBuffer()
    a11.copyToBuffer(b11)
    println(b11.mkString(",")) // 1,2,3,4

//    corresponds 判断两个序列的长度以及对应位置元素是否符合某个条件。
//    如果两个序列具有相同的元素数量并且 p(x, y)=true，则返回 true
    val a12=Array(1,2,3,4)
    val b12=Array(5,6,7,8)
    println(a12.corresponds(b12)(_ < _)) //true

//    count 统计符合条件的元素个数
    val a13=Array(1,2,3,4)
    println(a13.count(x => x > 2)) //2




  }

}

package test

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

  }
  val a=Array(7,8,9,10,11,12,13)

  println(a.par.aggregate((10, 0))(
    (x, y) => {
      println("seqop",x,y)
      if (y > x._1)
      {
        (x._1, x._2 + 1)
      }

      else
      {
        x
      }

    },
    (x, y) => {
      println("combop",x,y)
      (x._1, x._2 + y._2)
    }

  ))

  println("----------------------------------")

  println(a.par.aggregate(0)(
    (x, y) => {
      println("seqop",x, y)
      if (x > y) {
        x
      }
      else {
        y
      }
    },
    (x, y) => {
      println("combop",x, y)
      x + y
    }
  ))

  println("---------------------------------")


  println(a.aggregate((10, 0))(
    (x, y) => {
      if (y > x._1)
      {
        (x._1, x._2 + 1)
      }

      else
      {
        x
      }

    },
    (x, y) => {
      (x._1, x._2 + y._2)
    }

  ))












}

DEFFunctionTest

package test

object DEFFunctionTest {
  def main(args: Array[String]): Unit = {
    //diff 计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回
    val a=Array(1,2,3,4)
    val b=Array(3,4,5,6)
    val c=a.diff(b)
    println(c.mkString(","))

    //distinct 去除当前集合中重复的元素，只保留一个
    val a1=Array(1,2,3,4,4,3)
    val b1=a1.distinct
    println(b1.mkString(","))

    //drop 将当前数组中前 n 个元素去除，返回一个新数组
    val a2=Array(1,2,3,4)
    val b2=a2.drop(2)
    println(b2.mkString(","))

    //dropRight 功能同 drop，去掉尾部的 n 个元素
    val a3=Array(1,2,3,4)
    val b3=a3.dropRight(2)
    println(b3.mkString(","))

    //dropWhile 去除当前数组中符合条件的元素，返回剩余的数组，
    // 这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，
    // 直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

    //下面去除数组 a 中大于 2 的元素，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 (2,3,4)
    val a4 = Array(1, 2, 3, 4)
    val b4= a4.dropWhile(x => x < 2)
    println(b4.mkString(",")) // 2,3,4

    val a5 = Array(1, 2, 3, 4)
    val b5 = a5.dropWhile(x => x > 2)
    println(b5.mkString(",")) // 1,2,3,4

    //endsWith 判断当前序列是否以某个序列结尾
    val a6=Array(1,2,3,4)
    val b6=Array(3,4)
    println(a6.endsWith(b6)) //true

    //exists 判断当前数组是否包含符合条件的元素
    val a7=Array(1,2,3,4)
    println(a7.exists(x => x == 3)) //true

    println(a7.exists(x => x > 10)) //false

    //filter 取得当前数组中符合条件的元素，组成新的数组返回
    val a8=Array(1,2,3,4)
    val b8=a8.filter(x=>x>2)
//    val b8=a8.filterNot()
    println(b8.mkString(","))  //3,4

    //find 查找第一个符合条件的元素，返回 Option
    val a9=Array(1,2,3,4)
    val b9=a9.find(x=>x>2)
    println(b9)  //Some(3)

    //flatMap 对当前序列的每个元素进行操作，结果放入新序列返回，
    // 参数要求是 GenTraversableOnce 及其子类
    val a10=Array(1,2,3,4)
    val b10=a10.flatMap(x=> 1 to x)
    println(b10.mkString(",")) //1,1,2,1,2,3,1,2,3,4
    /**
      * 1,1,2,1,2,3,1,2,3,4
      * 从 1 开始，分别对集合 a 中的每个元素生成一个递增序列，过程如下
      * 1
      * 1,2
      * 1,2,3
      * 1,2,3,4
      */

    //flatten 扁平化，将二维数组的所有元素组合在一起，形成一个一维数组返回
    val a11=Array(Array(1,2,3),Array(4,5,7))
    val b11=a11.flatten
    println(b11.mkString(","))


    //forall 检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true
    val a12=Array(1,2,3,4)
    println(a12.forall(x => x > 0)) //true
    println(a12.forall(x => x > 2)) //false

    //foreach 遍历序列中的元素，进行 f 操作
//    def foreach(f: (A) ⇒ Unit): Unit
    val a13=Array(1,2,3,4,6)
    a13.foreach(x=>println(x*10))
    /**
      * 10
      * 20
      * 30
      * 40
      */
















  }

}

package test

object FoldLeftTest {
  //foldLeft 从左到右计算，简写方式：def /:[B](z: B)(op: (B, T) ⇒ B): B
  def seqno(m: Int, n: Int): Int = {
    val s = "seq_exp = %d + %d"
    println(s.format(m, n))
    m + n
  }

  def main(args: Array[String]): Unit = {
    val a = Array(1, 2, 3, 4)

    val b = a.foldLeft(5)(seqno) // 简写: (5 /: a)(_ + _)
    println("b = " + b)
    /**
      * seq_exp = 5 + 1
      * seq_exp = 6 + 2
      * seq_exp = 8 + 3
      * seq_exp = 11 + 4
      * b = 15
      */
  }

}

package test

object FoldRightTest {
  def seqno(m: Int, n: Int): Int = {
    val s = "seq_exp = %d + %d"
    println(s.format(m, n))
    m + n
  }

  def main(args: Array[String]): Unit = {
    val a = Array(1, 2, 3, 4)

    val b = a.foldRight(5)(seqno) // 简写: (a :\ 5)(_ + _)
    println("b = " + b)
    /**
      * seq_exp = 4 + 5
      * seq_exp = 3 + 9
      * seq_exp = 2 + 12
      * seq_exp = 1 + 14
      * b = 15
      */
  }

}

package test

object FoldTest {
  //fold 对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
  def seqno(m:Int,n:Int):Int={
    val s="seq_exp=%d+%d"
    println(s.format(m, n))
    m+n
  }

  def main(args: Array[String]): Unit = {
    val a12=Array(1,2,3,4)

    val b12=a12.fold(5)(seqno) //不分区
    println("b12="+b12)
    /**
      * seq_exp = 5 + 1
      * seq_exp = 6 + 2
      * seq_exp = 8 + 3
      * seq_exp = 11 + 4
      * b12 = 15
      */
    val c12=a12.par.fold(5)(seqno) //分区
    println("c12="+c12)

    /**
      * seq_exp=5+1
      * seq_exp=5+2
      * seq_exp=6+7
      * seq_exp=5+3
      * seq_exp=8+4
      * seq_exp=13+12
      * c12=25
      */
  }


}

GHIFunctionTest

package test

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

//    def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
    //groupBy 按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
    //把数组中小于 3 的元素分到一组，其他元素的分到另一组，返回 Map[String, Array[Int]]
    val a=Array(1,2,3,4)
    val b=a.groupBy(x=>x match{
      case x if (x<3)=>"small"
      case _ =>"big"
    })
    b.foreach(x => println(x._1 + ": " + x._2.mkString(",")))
    /**
      * small: 1,2
      * big: 3,4
      */

    val a1=Array(59,60,100,96,87,102)
    val b1=a1.groupBy(s=>s match{
      case s if (s<60)=>"不及格"
      case s if (s<90)=>"优秀"
      case s if (s<=100)=>"完美"
      case _=>"其他"
    })
    b1.foreach(s => println(s._1 + ": " + s._2.mkString(",")))

    /**
      * 其他: 102
      * 完美: 100,96
      * 优秀: 60,87
      * 不及格: 59
      */

    //grouped 按指定数量分组，每组有 size 个元素，返回一个迭代器
    val a2=Array(1,2,3,4,5)
    val b2=a2.grouped(2).toList
    b2.foreach(x => println("第 " + (b2.indexOf(x) + 1) + " 组: " + x.mkString(",")))

    /**
      * 第 1 组: 1,2
      * 第 2 组: 3,4
      * 第 3 组: 5
      */

    //hasDefiniteSize 检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false
    val a3 = Array(1, 2, 3, 4)
    println(a3.hasDefiniteSize) // true

    //head 返回序列的第一个元素，如果序列为空，将引发错误
    val a4 = Array(1, 2, 3, 4)
    println(a4.head) // 1

    //headOption 返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None
    val a5 = Array(1, 2, 3, 4)
    println(a5.headOption) // Some(1)

    //indexOf(elem) 返回元素 elem 在序列中第一次出现的索引
    val a6 = Array(1, 3, 2, 3, 4)
    println(a6.indexOf(3)) // 1

    //indexOf(elem, from) 返回元素 elem 在序列中第一次出现的索引，指定从索引 from 开始查找
    val a7 = Array(1, 3, 2, 3, 4)
    println(a7.indexOf(3, 2)) // 3

    //indexOfSlice(that) 检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引
    val a8 = Array(1,7,8,2, 3, 2, 3, 4)
    val b8 = Array(2, 3)
    println(a8.indexOfSlice(b8)) // 3

    //indexOfSlice(that, from) 检测当前序列中是否包含另一个序列 that
    // 指定从索引 from 开始查找，并返回第一次出现该序列的索引
    val a9 = Array(1, 2, 3, 2, 3, 4)
    val b9 = Array(2, 3)
    println(a9.indexOfSlice(b9, 2)) // 3

    //indexWhere(p) 返回当前序列中第一个满足条件 p 的元素的索引
    val a10 = Array(1, 2, 3, 4)
    println(a10.indexWhere(x => x > 2)) // 2

    //indexWhere(p, from) 返回当前序列中第一个满足条件 p 的元素的索引，指定从索引 from 开始查找
    val a11 = Array(1, 2, 3, 4)
    println(a11.indexWhere(x => x > 2, 3)) // 3

      //indices 返回当前序列索引集合
      val a12 = Array(1, 2, 3, 4)
      val b12 = a12.indices
      println(b12.mkString(",")) // 0,1,2,3

      //init 返回当前序列中不包含最后一个元素的序列
      val a13 = Array(1, 2, 3, 4)
      val b13 = a13.init
      println(b13.mkString(",")) // 1,2,3

      //inits 对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，
      // 每一步都进行 init 操作，上一步的结果作为下一步的操作对象
      val a14 = Array(1, 2, 3, 4)
      val b14 = a14.inits.toList
      for (i <- 0 until b14.length) {
          val s = "第 %d 个值: %s"
          println(s.format(i + 1, b14(i).mkString(",")))
      }
      /**
        * 第 1 个值: 1,2,3,4
        * 第 2 个值: 1,2,3
        * 第 3 个值: 1,2
        * 第 4 个值: 1
        * 第 5 个值:
        */

      //intersect 取两个集合的交集
      val a15 = Array(1, 2, 3, 4)
      val b15 = Array(3, 4, 5, 6)
      val c15 = a15.intersect(b15)
      println(c15.mkString(",")) // 3,4

      //isDefinedAt 判断序列中是否存在指定索引
      val a16=Array(1,2,3,4)
      println(a16.isDefinedAt(1)) //true
      println(a16.isDefinedAt(5)) //false

      //isEmpty 判断序列是否为空
      val a17=Array(1,2,3,4)
      val b17=new Array[Int](0)
      println(a17.isEmpty) //false
      println(b17.isEmpty) //true
      println("-------------------------------------------------")

      //isTraversableAgain 判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，
      // 对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写
      val a18 = Array(1, 2, 3, 4)
      val b18 = a18.iterator
      println(a18.isTraversableAgain) // true
      println(b18.isTraversableAgain) // false











  }

}

LMNFunctionTest

package test

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

    //last 返回序列的最后一个元素，如果序列为空，将引发错误
    val a = Array(1, 2, 3, 4)
    println(a.last) // 4

    //lastIndexOf(elem) 返回元素 elem 在序列中最后一次出现的索引
    val a1 = Array(1, 3, 2, 3, 4)
    println(a1.lastIndexOf(3)) // 3

    //lastIndexOf(elem, end) 返回元素 elem 在序列中最后一次出现的索引，
    // 指定在索引 end 之前（包括）的元素中查找
    val a2 = Array(1, 3, 2, 3, 4)
    println(a2.lastIndexOf(3, 2)) // 1

    //lastIndexOfSlice(that) 检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引
    val a3 = Array(1, 2, 3, 2, 3, 4)
    val b3 = Array(2, 3)
    println(a3.lastIndexOfSlice(b3)) // 3

    //lastIndexOfSlice(that, end) 检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引，
    // 指定在索引 end 之前（包括）的元素中查找
    val a4 = Array(1, 2, 3, 2, 3, 4)
    val b4 = Array(2,3)
    println(a4.lastIndexOfSlice(b4, 2)) // 1

    //lastIndexWhere(p) 返回当前序列中最后一个满足条件 p 的元素的索引
    val a5=Array(1,2,3,4,1,8)
    println(a5.lastIndexWhere(_>2)) //5

    //lastIndexWhere(p, end) 返回当前序列中最后一个满足条件 p 的元素的索引，
    // 指定在索引 end 之前（包括）的元素中查找
    val a6 = Array(1, 2, 3, 4)
    println(a6.lastIndexWhere(x => x > 2, 2)) // 2

    //lastOption 返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
    val a7 = Array(1, 2, 3, 4)
    println(a7.lastOption) // Some(4)

    //length 返回序列元素个数
    val a8 = Array(1, 2, 3, 4)
    println(a8.length) // 4

    //lengthCompare 比较序列的长度和参数 len，返回序列的长度 - len
    //def lengthCompare(len: Int): Int
    val a9 = Array(1, 2, 3, 4)
    println(a9.lengthCompare(3)) // 1
    println(a9.lengthCompare(4)) // 0
    println(a9.lengthCompare(5)) // -1

    //map def map[B](f: (A) ⇒ B): Array[B] 对序列中的元素进行 f 操作，返回生成的新序列
    val a10 = Array(1, 2, 3, 4)
    val b10 = a10.map(x => x * 10)
    println(b10.mkString(",")) // 10,20,30,40

    //max 返回序列中最大的元素
    val a11 = Array(1, 2, 3, 4)
    println(a11.max) // 4

    //maxBy 返回序列中符合条件的第一个元素
    val a12 = Array(1, 2, 3, 4)
    println(a12.maxBy(x => x > 2)) // 3

    //min 返回序列中最小的元素
    val a13 = Array(1, 2, 3, 4)
    println(a13.min) // 1

    //minBy 返回序列中不符合条件的第一个元素
    val a14 = Array(1, 2, 3, 4)
    println(a14.minBy(x => x < 2)) // 2

    //mkString 将序列中所有元素拼接成一个字符串
    val a15 = Array(1, 2, 3, 4)
    println(a15.mkString) // 1234

    //mkString(sep) 将序列中所有元素拼接成一个字符串，以 sep 作为元素间的分隔符
    val a16 = Array(1, 2, 3, 4)
    println(a16.mkString(",")) // 1,2,3,4

    //mkString(start, sep, end) 将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾
    val a17 = Array(1, 2, 3, 4)
    println(a17.mkString("(", ",", ")")) // (1,2,3,4)

    //nonEmpty 判断序列是否不为空
    val a18 = Array(1, 2, 3, 4)
    val b18 = new Array[Int](0)
    println(a18.nonEmpty) // true
    println(b18.nonEmpty) // false









  }

}

NeilVicia

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Scala数组、集合函数大全A-N

目录++ ++： +：：+ /: :\ACFunctionTestDEFFunctionTestGHIFunctionTestLMNFunctionTest++ ++： +：：+ /: :\package testobject demo1 { def main(args: Array[String]): Unit = { val arr=Array(1,2,3,4) val first=arr(0) arr(3)=100 ......
复制链接

扫一扫