Scala系列（二）Scala數組----超詳細常用方法及其用法

寫在前面： 我是「nicedays」，一枚喜愛做特效，聽音樂，分享技術的大數據開發猿。這名字是來自world order樂隊的一首HAVE A NICE DAY。如今，走到現在很多坎坷和不順，如今終於明白nice day是需要自己賦予的。
白駒過隙，時光荏苒，珍惜當下~~
寫博客一方面是對自己學習的一點點總結及記錄，另一方面則是希望能夠幫助更多對大數據感興趣的朋友。如果你也對 大數據與機器學習感興趣，可以關注我的動態 https://blog.csdn.net/qq_35050438，讓我們一起挖掘數據與人工智能的價值~

Scala函數之數組：

Array方法：

++

合併數組

var c = Array(1,2,3)
var b = Array(4,5,6)
b++c

++:

合併數組並將右邊的類型作爲最終結果返回

 val a = List(1,2)
 val b = scala.collection.mutable.LinkedList(3,4)
 val c = a ++: b
// 最後c爲LinkList類型

+:與:+

在數組前添加一個元素

val k = 0
val a = List(1,2)
val c = k +: a // c中的內容是 （0,1,2）
val d = a :+ k // d中的內容是 （1,2,0）
數組在哪冒號在哪

/:與:\–foldleft的簡寫

對數組中所有的元素進行相同的操作

val a = List(1,2,3,4)
val c = (10 /: a)(_+_)   // 1+2+3+4+10
val d = (10 /: a)(_*_)   // 1*2*3*4*10
println("c:"+c)   // c:20
println("d:"+d)   // d:240
冒號在哪邊，集合就在哪邊

addString()

val a = List(1,2,3,4)
val b = new StringBuilder("678")
val c = a.addString(b)   // c中的內容是  1234
val d = a.addString(b,",") // 連接字符串時每個元素按分隔符隔開 
val e = a.addString(b,"shou",",","wei") // 在首尾各加一個字符串，並指定sep分隔符

aggregate()

聚合計算，aggregate是柯里化方法，參數是兩個方法

apply()

去出指定索引處得元素

arr.apply(index)

canEqual()

判斷兩個對象是否可以進行比較

arr.canEqual()

charAt()–字符數組纔有

val chars = Array('a','b','c')
c.cahrAt()

clone()

創建一個副本，不是引用，是深拷貝

val chars = Array('a','b','c')
val newchars = chars.clone()

collect()

執行一個並行計算，得到一個新的數組對象

   val chars = Array('a','b','c')
   val newchars = chars.collect(fun)
   println("newchars:"+newchars.mkString(","))
  //我們通過下面的偏函數，把chars數組的小寫a轉換爲大寫的A
  val fun:PartialFunction[Char,Char] = {
    case 'a' => 'A'
    case x => x
  }
  /**輸出結果是 newchars:A,b,c */

val newchars = Array(22,442,653,3467)
val fun:PartialFunction[Char,Char] = {
	case y if %  2 == 0 =>  y + 5
}

combinations()

拿到數組對應長度得所有排列組合

val arr = Array("a","b","c")
val newarr = arr.combinations(2)// 返回了一個迭代器，長度爲2得排列組合
newarr.foreach((item) => println(item.mkString(",")))
 /**
    a,b
    a,c
    b,c
 */

contains()

序列中是否包含指定對象

arr.contains(2)

containSlice()

判斷當前序列中是否包含另一個序列

val a = List(1,2,3,4)
val b = List(2,3)
println(a.containsSlice(b))  //true

copyToArray()

數組中的內容拷貝到另外一個數組

// 將a得數組拷貝給b，得從索引2開始拷
a.copyToArray(b,2)

copyToBuffer()

 val a:ArrayBuffer[Char]  = ArrayBuffer()
    b.copyToBuffer(a)
    println(a.mkString(","))

corresponds()

判斷兩個序列長度以及對應位置元素是否符合某個條件。如果兩個序列具有相同的元素數量並且對應位置得條件都成立，返回結果爲true

val a = Array(1, 2, 3)
val b = Array(4, 5,6)
println(a.corresponds(b)(_<_))  //true

count()

統計符合條件的元素個數，x>2 大於2才做統計
下面統計大於 2 的元素個數

val a = Array(1, 2, 3)
println(a.count({x:Int => x > 2}))  // count = 1

diff()

返回當前數組與另一個數組比較後獨一無二得元素

val a = Array(1, 2, 3,4)
val b = Array(4, 5,6,7)
val c = a.diff(b)
println(c.mkString) //1,2,3

distinct()

去除當前集合得重複元素

val a = Array(1, 2, 3,4,4,5,6,6)
val c = a.distinct
println(c.mkString(","))    // 1,2,3,4,5,6

drop()

當前序列中前 n 個元素去除

val a = Array(1, 2, 3,4)
val c = a.drop(2)
// 3,4

dropRight()

當前序列中尾部n 個元素去除

dropWhile()

去除符合條件得元素
但是有一個條件：從當前數組的第一個元素起，就要滿足條件，直到碰到第一個不滿足條件的元素結束（即使後面還有符合條件的元素）

//下面去除大於2的，第一個元素 3 滿足，它後面的元素 2 不滿足，所以返回 2,3,4
val a = Array(3, 2, 3,4)
val c = a.dropWhile( {x:Int => x > 2} )
println(c.mkString(","))
 
//如果數組 a 是下面這樣，第一個元素就不滿足，所以返回整個數組 1, 2, 3,4
val a = Array(1, 2, 3,4)

endsWith()

判斷是否以某個序列結尾

val a = Array(3, 2, 3,4)
val b = Array(3,4)
println(a.endsWith(b))  //true

exists()

判斷當前數組是否包含符合條件的元素

 val a = Array(3, 2, 3,4)
 println(a.exists( {x:Int => x==3} ))   //true
 println(a.exists( {x:Int => x==30} ))  //false

filter()

取得當前數組中符合條件的元素，組成新的數組返回

val a = Array(3, 2, 3, 4)
val b = a.filter( {x:Int => x > 2} )
println(b.mkString(","))    //3,3,4

find()

查找第一個符合條件得某個東西

val a = Array(1, 2, 3,4)
val b = a.find( {x:Int => x>2} )
// val b = a.find( x => x > 2 )
println(b)  // Some(3)
val b = a.find( {x:Int => x>2} ).get // 拿值

flatMap()

flat和map，先map後flatten、
map一般都會形成嵌套集合，需要flat扁平化

val a = Array(1, 2, 3,4)
val b = a.flatMap(x=>1 to x)
println(b.mkString(","))
/**
1,1,2,1,2,3,1,2,3,4
從1開始，分別於集合a的每個元素生成一個遞增序列，過程如下
1
1,2
1,2,3
1,2,3,4
*/

fold

對序列中的每個元素進行二元運算

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
  def combine(m:Int,n:Int): Int ={
    val s = "com_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.fold(5)(seqno)
    /** 運算過程
    seq_exp=5+1
    seq_exp=6+2
    seq_exp=8+3
    seq_exp=11+4
    */
    val c = a.par.aggregate(5)(seqno,combine)
    /** 運算過程
    seq_exp=5+1
    seq_exp=5+4
    seq_exp=5+3
    com_exp=8+9
    seq_exp=5+2
    com_exp=6+7
    com_exp=13+17
    */

foldRight()

  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1, 2, 3,4)
    val b = a.foldRight(5)(seqno)
    /** 運算過程
    seq_exp=4+5
    seq_exp=3+9
    seq_exp=2+12
    seq_exp=1+14
    */
    /**
    簡寫 (a :\ 5)(_+_)
    */

foreach()

遍歷序列中的元素，進行 f 操作,類似迭代器，只能執行一次

    val a = Array(1, 2, 3,4)
    a.foreach(x => println(x*10))
    /**
    10
    20
    30
    40
    */

group by

按條件分組，條件由 f 匹配，返回值是Map類型，每個key對應一個序列，下面代碼實現的是，把小於3的數字放到一組，大於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"
    })

grouped()

按指定數量分組，每組有 size 數量個元素，返回一個集合迭代器

val a = Array(1, 2, 3,4,5)
val b = a.grouped(3).toList
b.foreach((x) => println("第"+(b.indexOf(x)+1)+"組:"+x.mkString(",")))
/**
第1組:1,2,3
第2組:4,5
*/

hasDefiniteSize()

檢測序列是否存在有限的長度，對應Stream這樣的流數據，返回false

val a = Array(1, 2, 3,4,5)
println(a.hasDefiniteSize)  //true

head()

拿頭元素

arr.head

last()

拿尾元素

arr.last

indexOf()

elem在序列中的索引，找到第一個就返回

val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3))   // return 1

// 返回elem在序列中的索引，可以指定從某個索引處（from）開始查找，找到第一個就返回
val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3,2)) // return 3

indexOfSlice()

檢測當前序列中是否包含另一個序列（that），並返回第一個匹配出現的元素的索引

 val a = Array(1, 3, 2, 3, 4)
 val b = Array(2,3)
 println(a.indexOfSlice(b))  // return 2

indexWhere()

返回當前序列中第一個滿足 p 條件的元素的索引，可以指定從 from 索引處開始

 val a = Array(1, 2, 3, 4, 5, 6)
 println(a.indexWhere( {x:Int => x>3},4))    // return 4

indices()

 val a = Array(10, 2, 3, 40, 5)
 val b = a.indices
 println(b.mkString(","))    // 0,1,2,3,4

init()

返回當前序列中不包含最後一個元素的序列

val a = Array(10, 2, 3, 40, 5)
val b = a.init
println(b.mkString(","))    // 10, 2, 3, 40

tail()

去頭元素

 val a = Array(10, 2, 3, 40, 5)
 val b = a.tail
 println(b.mkString(","))    // 2, 3, 40，5

intersect()

取兩個集合的交集

  val a = Array(1, 2, 3, 4, 5)
  val b = Array(3, 4, 6)
  val c = a.intersect(b)
  println(c.mkString(","))    //return 3,4

isDefinedAt()

判斷序列中是否存在指定索引

 val a = Array(1, 2, 3, 4, 5)
 println(a.isDefinedAt(1))   // true
 println(a.isDefinedAt(10))  // false

isEmpty()

判斷當前序列是否爲空

Scala系列（二）Scala數組----超詳細常用方法及其用法

Scala函數之數組：

Array方法：

通過HPA+CronHPA組合應對業務複雜彈性伸縮場景

ZooKeeper系列（一）ZooKeeper基本簡介與命令和集羣環境搭建

Hadoop系列 (一) 補--Hadoop完全分佈式環境搭建

Hadoop系列 ( 三 ) MapReduce存在的意義----MapReduce究竟做了些什麼？？

Scala系列（二）Scala數組----超詳細常用方法及其用法

Sqoop系列（一）通過sqoop將關係型數據遷移到HBase和Hive上

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Scala系列 （二）Scala數組----超詳細常用方法及其用法

Scala函數之數組：

Array方法：

Scala系列（二）Scala數組----超詳細常用方法及其用法