Scala基礎入門(二)

阿新 • • 發佈：2018-12-23

1.陣列

1.1.陣列
- 1.1.定長陣列和變長陣列
  （1）定長陣列定義格式：
  val arr=new Array[T] (陣列長度)
  （2）變長陣列定義格式：
  val arr = ArrayBuffer[T] () 注意需要導包：import scala.collection.mutable.ArrayBuffer

import scala.collection.mutable.ArrayBuffer
object ArrayDemo {
  def main(args: Array[String]) {

    //初始化一個長度為8的定長陣列，其所有元素均為0
    val arr1 = new 
 Array[Int](8)
    //直接列印定長陣列，內容為陣列的hashcode值
    println(arr1)
    //將陣列轉換成陣列緩衝，就可以看到原陣列中的內容了
    //toBuffer會將陣列轉換長陣列緩衝
    println(arr1.toBuffer)

    //注意：如果new，相當於呼叫了陣列的apply方法，直接為陣列賦值
    //初始化一個長度為1的定長陣列
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)

    //定義一個長度為3的定長陣列
    val arr3 = Array("hadoop" 
, "storm", "spark")
    //使用()來訪問元素
    println(arr3(2))

    //////////////////////////////////////////////////
    //變長陣列（陣列緩衝）
    //如果想使用陣列緩衝，需要匯入import scala.collection.mutable.ArrayBuffer包
    val ab = ArrayBuffer[Int]()
    //向陣列緩衝的尾部追加一個元素
    //+=尾部追加元素
    ab += 1
    //追加多個元素
    ab += (2, 3, 4, 5)
    //追加一個數組++=
    ab ++= Array(6, 7)
    //追加一個數組緩衝
    ab ++= ArrayBuffer(8 
,9)
    //列印陣列緩衝ab

    //在陣列某個位置插入元素用insert，從某下標插入
    ab.insert(0, -1, 0)
    //刪除陣列某個位置的元素用remove  按照下標刪除
    ab.remove(0)
    println(ab)

  }
}

1.2. 遍歷陣列
- (1).增強for迴圈
- (2).好用的until會生成腳標，0 until 10 包含0不包含10

object ForArrayDemo {
  def main(args: Array[String]) {
    //初始化一個數組
    val arr = Array(1,2,3,4,5,6,7,8)
    //增強for迴圈
    for(i <- arr)
      println(i)

    //好用的until會生成一個Range
    //reverse是將前面生成的Range反轉
    for(i <- (0 until arr.length).reverse)
      println(arr(i))
  }
}

1.3.陣列轉換
yield關鍵字將原始的陣列進行轉換會產生一個新的陣列，原始的陣列不變

object ArrayYieldDemo {
  def main(args: Array[String]) {
    //定義一個數組
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //將偶數取出乘以10後再生成一個新的陣列
    val res = for (e <- arr if e % 2 == 0) yield e * 10
    println(res.toBuffer)

    //更高階的寫法,用著更爽
    //filter是過濾，接收一個返回值為boolean的函式
    //map相當於將陣列中的每一個元素取出來，應用傳進去的函式
    val r = arr.filter(_ % 2 == 0).map(_ * 10)
    println(r.toBuffer)

  }
}

1.4陣列常用演算法
在Scala中，陣列上的某些方法對陣列進行相應的操作非常方便

2.對映

在Scala中，把雜湊表這種資料結構叫做對映
* 2.1構建對映
* (1)val map=Map(鍵->值，鍵->值….)
* (2)利用元組構建 val map=Map((鍵，值),(鍵，值),(鍵，值)….)
圖片6.png

2.2.獲取和修改對映中的值
- 獲取對映中的值：
  值=map(鍵)
  好用的getOrElse (如果對映中有值,返回對映中的值,沒有就返回預設值)
  注意：在Scala中，有兩種Map，一個是immutable包下的Map，該Map中的內容不可變；另一個是mutable包下的Map，該Map中的內容可變
  通常我們在建立一個集合是會用val這個關鍵字修飾一個變數（相當於java中的final），那麼就意味著該變數的引用不可變，該引用中的內容是不是可變，取決於這個引用指向的集合的型別

3.元組

對映是K/V對偶的集合，對偶是元組的最簡單形式，元組可以裝著多個不同型別的值。
* 3.1建立元組
* （1）元組是不同型別的值的聚集；對偶是最簡單的元組。
* （2）元組表示通過將不同的值用小括號括起來，即表示元組。

**`建立元組格式：`**
val tuple=(元素,元素...)

3.2獲取元組中的值
- 獲取元組中的值格式：
  使用下劃線加腳表，例如 t._1 t._2 t._3
  注意：元組中的元素腳標是從1開始的
3.3將對偶的集合轉換成對映
- 將對偶的集合裝換成對映：
  呼叫其toMap 方法
3.4.拉鍊操作
- (1).使用zip命令可以將多個值繫結在一起
  
  注意：如果兩個陣列的元素個數不一致，拉鍊操作後生成的陣列的長度為較小的那個陣列的元素個數
- (2).如果其中一個元素的個數比較少，可以使用zipAll用預設的元素填充

4.集合

Scala的集合有三大類：序列Seq、Set、對映Map，所有的集合都擴充套件自Iterable特質
在Scala中集合有可變（mutable）和不可變（immutable）兩種型別，immutable型別的集合初始化後就不能改變了（注意與val修飾的變數進行區別）

4.1 List

(1)不可變的序列 import scala.collection.immutable._

在Scala中列表要麼為空（Nil表示空列表）要麼是一個head元素加上一個tail列表。
9 :: List(5, 2)  :: 操作符是將給定的頭和尾建立一個新的列表 
注意：:: 操作符是右結合的，如9 :: 5 :: 2 :: Nil相當於 9 :: (5 :: (2 :: Nil))


list常用的操作符：
++[B](that: GenTraversableOnce[B]): List[B] 從列表的尾部新增另外一個列表
++: [B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[List[A], B, That]): That 在列表的頭部新增一個列表
+: (elem: A): List[A] 在列表的頭部新增一個元素
:+ (elem: A): List[A] 在列表的尾部新增一個元素
:: (x: A): List[A]     在列表的頭部新增一個元素
::: (prefix: List[A]): List[A] 在列表的頭部新增另外一個列表
val left = List(1,2,3)
val right = List(4,5,6)
//以下操作等價
left ++ right      // List(1,2,3,4,5,6)
left ++: right     // List(1,2,3,4,5,6)
right.++:(left)    // List(1,2,3,4,5,6)
right.:::(left)     // List(1,2,3,4,5,6)
//以下操作等價
0 +: left    //List(0,1,2,3)
left.+:(0)   //List(0,1,2,3)
//以下操作等價
left :+ 4    //List(1,2,3,4)
left.:+(4)   //List(1,2,3,4)
//以下操作等價
0 :: left      //List(0,1,2,3)
left.::(0)     //List(0,1,2,3)

(2)可變的序列 import scala.collection.mutable._

import scala.collection.mutable.ListBuffer

object MutListDemo extends App{
  //構建一個可變列表，初始有3個元素1,2,3
  val lst0 = ListBuffer[Int](1,2,3)
  //建立一個空的可變列表
  val lst1 = new ListBuffer[Int]
  //向lst1中追加元素，注意：沒有生成新的集合
  lst1 += 4
  lst1.append(5)

  //將lst1中的元素最近到lst0中， 注意：沒有生成新的集合
  lst0 ++= lst1

  //將lst0和lst1合併成一個新的ListBuffer 注意：生成了一個集合
  val lst2= lst0 ++ lst1

  //將元素追加到lst0的後面生成一個新的集合
  val lst3 = lst0 :+ 5

  //刪除元素,注意：沒有生成新的集合
  val lst4 = ListBuffer[Int](1,2,3,4,5)
  lst4 -= 5

  //刪除一個集合列表,生成了一個新的集合
  val lst5=lst4--List(1,2)

  //把可變list 轉換成不可變的list 直接加上toList
  val lst6=lst5.toList

  //把可變list 轉變陣列用toArray
  val lst7=lst5.toArray

  println(lst0)
  println(lst1)
  println(lst2)
  println(lst3)
  println(lst4)
  println(lst5)
  println(lst6)
  println(lst7)

}

4.2.Set
(1)不可變的Set import scala.collection.immutable._
Set代表一個沒有重複元素的集合；將重複元素加入Set是沒有用的，而且 Set 是不保證插入順序的，即 Set 中的元素是亂序的。
定義：val set=Set(元素,元素,…..)

//定義一個不可變的Set集合
scala> val set =Set(1,2,3,4,5,6,7)
set: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)

//元素個數
scala> set.size
res0: Int = 7

//取集合最小值
scala> set.min
res1: Int = 1

//取集合最大值
scala> set.max
res2: Int = 7

//將元素和set1合併生成一個新的set，原有set不變
scala> set + 8
res3: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)

scala> val set1=Set(7,8,9)
set1: scala.collection.immutable.Set[Int] = Set(7, 8, 9)

//兩個集合的交集
scala> set & set1
res4: scala.collection.immutable.Set[Int] = Set(7)

//兩個集合的並集
scala> set ++ set1
res5: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

//在第一個set基礎上去掉第二個set中存在的元素
scala> set -- set1
res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

//返回第一個不同於第二個set的元素集合
scala> set &~ set1
res7: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)


//計算符合條件的元素個數
scala> set.count(_ >5)
res8: Int = 2

/返回第一個不同於第二個的元素集合
scala> set.diff(set1)
res9: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

/返回第一個不同於第二個的元素集合
scala> set1.diff(set)
res10: scala.collection.immutable.Set[Int] = Set(8, 9)

//取子set(2,5為元素位置, 從0開始，包含頭不包含尾)
scala> set.slice(2,5)
res11: scala.collection.immutable.Set[Int] = Set(6, 2, 7)

//迭代所有的子set，取指定的個數組合
scala> set1.subsets(2).foreach(x=>println(x))
Set(7, 8)
Set(7, 9)
Set(8, 9)

(2)可變的Set import scala.collection.mutable._

//匯入包
scala> import scala.collection.mutable
import scala.collection.mutable
//定義一個可變的Set
scala> val set1=new HashSet[Int]()
set1: scala.collection.mutable.HashSet[Int] = Set()

//新增元素
scala> set1 += 1
res1: set1.type = Set(1)

//新增元素  add等價於+=
scala> set1.add(2)
res2: Boolean = true
scala> set1
res3: scala.collection.mutable.HashSet[Int] = Set(1, 2)

//向集合中新增元素集合
scala> set1 ++=Set(1,4,5)
res5: set1.type = Set(1, 5, 2, 4)

//刪除一個元素
scala> set1 -=5
res6: set1.type = Set(1, 2, 4)

//刪除一個元素
scala> set1.remove(1)
res7: Boolean = true
scala> set1
res8: scala.collection.mutable.HashSet[Int] = Set(2, 4)

4.3.Map
(1)不可變的Map import scala.collection.immutable._

定義Map集合
1.val map=Map(鍵->值,鍵->值...)
2.利用元組構建  val map=Map((鍵，值),(鍵，值),(鍵，值)....)
展現形式：
val  map = Map(“zhangsan”->30,”lisi”->40)
val  map = Map((“zhangsan”,30),(“lisi”,40))

3.操作map集合
獲取值： 值=map(鍵)
原則：通過先獲取鍵，在獲取鍵對應值。

4.遍歷map集合


scala> val imap=Map("zhangsan" -> 20,"lisi" ->30)
imap: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 20, lisi -> 30)
//方法一：顯示所有的key
scala> imap.keys
res0: Iterable[String] = Set(zhangsan, lisi)

//方法二：顯示所有的key
scala> imap.keySet
res1: scala.collection.immutable.Set[String] = Set(zhangsan, lisi)

//通過key獲取value
scala> imap("lisi")
res2: Int = 30

//通過key獲取value 有key對應的值則返回，沒有就返回預設值0，
scala> imap.getOrElse("zhangsan",0)
res4: Int = 20

//沒有對應的key，返回預設0
scala> imap.getOrElse("zhangsan1",0)
res5: Int = 0
//由於是不可變map,故不能向其新增、刪除、修改鍵值對

* (2)可變的Map  import scala.collection.mutable._

//導包
import scala.collection.mutable
//宣告一個可變集合
scala> val user =mutable.HashMap("zhangsan"->50,"lisi" -> 100)
user: scala.collection.mutable.HashMap[String,Int] = Map(lisi -> 100, zhangsan -> 50)

//新增鍵值對
scala> user +=("wangwu" -> 30)
res0: user.type = Map(lisi -> 100, zhangsan -> 50, wangwu -> 30)

//新增多個鍵值對
scala> user += ("zhangsan0" -> 30,"lisi0" -> 20)
res1: user.type = Map(zhangsan0 -> 30, lisi -> 100, zhangsan -> 50, lisi0 -> 20,wangwu -> 30)

//方法一：顯示所有的key
scala> user.keys
res2: Iterable[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)

//方法二：顯示所有的key
scala> user.keySet
res3: scala.collection.Set[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)

//通過key獲取value
scala> user("zhangsan")
res4: Int = 50

//通過key獲取value 有key對應的值則返回，沒有就返回預設值0，
scala> user.getOrElse("zhangsan",0)
res5: Int = 50

//沒有對應的key，返回預設0
scala> user.getOrElse("zhangsan1",0)
res6: Int = 0

//更新鍵值對
scala> user("zhangsan") = 55
scala> user("zhangsan")
res8: Int = 55

//更新多個鍵值對
scala> user += ("zhangsan" -> 60, "lisi" -> 50)
res9: user.type = Map(zhangsan0 -> 30, lisi -> 50, zhangsan -> 60, lisi0 -> 20,wangwu -> 30)

//刪除key
scala> user -=("zhangsan")
res14: user.type = Map(zhangsan0 -> 30, lisi -> 50, lisi0 -> 20, wangwu -> 30)

//刪除key
scala>user.remove("zhangsan0")

//遍歷map 方法一：模式匹配
scala> for((x,y) <- user) println(x+" -> "+y)
lisi -> 50
lisi0 -> 20
wangwu -> 30

//遍歷map 方法二：通過key值
scala> for(x<- user.keys) println(x+" -> "+user(x))
lisi -> 50
lisi0 -> 20
wangwu -> 30

//遍歷map 方法三：通過foreach
scala>  user.foreach{case (x,y) => println(x+" -> "+y)}
lisi -> 50
lisi0 -> 20
wangwu -> 30

Scala基礎入門(二)

1.陣列

2.對映

3.元組

4.集合

Scala基礎入門(二)

Scala基礎入門（二） Scala下載、安裝教程

scala 基礎十二 scala apply的使用，工廠方法和單例模式的實現

Scala 基礎入門教程

Scala基礎入門 (一)

Scala基礎入門教程(三)

Scala基礎入門教程(一)

Scala基礎入門：使用Eclipse IDE編寫第一個Scala程式

yii2框架-restful的基礎入門(二十一)

Scala基礎入門（三）使用Scala IDE編寫第一個Scala程式

Linux 常用命令基礎入門二

大數據入門第二十天——scala入門（二）scala基礎

Scala學習（二）---入門基礎知識

Qt入門之基礎篇 ( 二 ) ：Qt項目建立、編譯、運行和發布過程解析

PHP基礎入門（二）【PHP函數基礎】

02-Linux基礎入門（二）

[Spring框架]Spring AOP基礎入門總結二:Spring基於AspectJ的AOP的開發.

JavaScript基礎入門教程（二）

PHP基礎入門（二）

Scala學習之路----基礎入門

Scala基礎入門(二)

1.陣列

2.對映

3.元組

4.集合

相關推薦