linuxscala命令

㈠ scala maven sbt 哪個

SBT是Simple Build Tool的簡稱，如果讀者使用過Maven，那麼可以簡單將SBT看做是Scala世界的Maven，雖然二者各有優劣，但完成的工作基本是類似的。

雖然Maven同樣可以管理Scala項目的依賴並進行構建， 但SBT的某些特性卻讓人如此著迷，比如：

* 使用Scala作為DSL來定義build文件（one language rules them all）;
* 通過觸發執行(trigger execution)特性支持持續的編譯與測試；
* 增量編譯；^[SBT的增量編譯支持因為如此優秀，已經剝離為Zinc，可被Eclipse, Maven,Gradle等使用]
* 可以混合構建java和Scala項目；
* 並行的任務執行；
* 可以重用Maven或者ivy的repository進行依賴管理；

等等這些，都是SBT得以在Scala的世界裡廣受歡迎的印記。

SBT的發展可以分為兩個階段， 即SBT_0.7.x時代以及SBT_0.10.x以後的時代。

目前來講， SBT_0.7.x已經很少使用， 大部分公司和項目都已經遷移到0.10.x以後的版本上來，最新的是0.12版本。 0.10.x之後的版本build定義採用了新的Settings系統，與最初0.7.x版本採用純Scala代碼來定義build文件大相徑庭，雖然筆者在遷移之前很抵觸（因為0.7.x中採用Scala定義build文件的做法可以體現很好的統一性），但還是升級並接納了0.10.x以後的版本，並且也逐漸意識到， 雖然新的版本初看起來很復雜，但一旦了解了其設計和實現的哲學跟思路，就會明白這種設計可以更便捷的定義build文件。而且可選的build文件方式也同樣運行採用Scala代碼來定義，即並未放棄統一性的思想。

以上是SBT的簡單介紹，如果讀者已經急於開始我們的SBT之旅，那麼讓我們先從SBT的安裝和配置開始吧！

## SBT安裝和配置

SBT的安裝和配置可以採用兩種方式，一種是所有平台都通用的安裝配置方式，另一種是跟平台相關的安裝和配置方式，下面我們分別對兩種方式進行詳細介紹。

### 所有平台通用的安裝配置方式
所有平台通用的安裝和配置方式只需要兩步：

1. 下載sbt boot launcher
- 本書採用最新的sbt0.12，其下載地址為<http://typesafe.artifactoryonline.com/typesafe/ivy-releases/org.scala-sbt/sbt-launch/0.12.0/sbt-launch.jar>；
2. 創建sbt啟動腳本（啟動腳本是平台相關的）
- 如果是linux/Unit系統，創建名稱為sbt的腳本，並賦予其執行許可權，並將其加到PATH路徑中； sbt腳本內容類似於
``java -Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=384M -jar `dirname $0`/sbt-launch.jar "$@"``， 可以根據情況調整合適的java進程啟動參數；
- 如果是Windows系統，則創建sbt.bat命令行腳本，同樣將其添加到PATH路徑中。 腳本內容類似於``set SCRIPT_DIR=%~dp0 \n
java -Xmx512M -jar "%SCRIPT_DIR%sbt-launch.jar" %*``

以上兩步即可完成sbt的安裝和配置。

### 平台相關的安裝配置方式
筆者使用的是Mac系統，安裝sbt只需要執行``brew install sbt``即可（因為我已經安裝有homebrew這個包管理器），使用macport同樣可以很簡單的安裝sbt - ``sudo port install sbt``;

㈡ 大數據技術是學什麼的

大數據需要學什麼？

1. Java編程技術

Java編程技術是大數據學習的基礎，Java是一種強類型語言，擁有極高的跨平台能力，可以編寫桌面應用程序、Web應用程序、分布式系統和嵌入式系統應用程序等，是大數據工程師最喜歡的編程工具，因此，想學好大數據，掌握Java基礎是必不可少的!

2.Linux命令

對於大數據開發通常是在Linux環境下進行的，相比Linux操作系統，Windows操作系統是封閉的操作系統，開源的大數據軟體很受限制，因此，想從事大數據開發相關工作，還需掌握Linux基礎操作命令。

3. Hadoop

Hadoop是大數據開發的重要框架，其核心是HDFS和MapRece，HDFS為海量的數據提供了存儲，MapRece為海量的數據提供了計算，因此，需要重點掌握，除此之外，還需要掌握Hadoop集群、Hadoop集群管理、YARN以及Hadoop高級管理等相關技術與操作!

4. Hive

Hive是基於Hadoop的一個數據倉庫工具，可以將結構化的數據文件映射為一張資料庫表，並提供簡單的sql查詢功能，可以將sql語句轉換為MapRece任務進行運行，十分適合數據倉庫的統計分析。對於Hive需掌握其安裝、應用及高級操作等。

5. Avro與Protobuf

Avro與Protobuf均是數據序列化系統，可以提供豐富的數據結構類型，十分適合做數據存儲，還可進行不同語言之間相互通信的數據交換格式，學習大數據，需掌握其具體用法。

6.ZooKeeper

ZooKeeper是Hadoop和Hbase的重要組件，是一個為分布式應用提供一致性服務的軟體，提供的功能包括：配置維護、域名服務、分布式同步、組件服務等，在大數據開發中要掌握ZooKeeper的常用命令及功能的實現方法。

7. HBase

HBase是一個分布式的、面向列的開源資料庫，它不同於一般的關系資料庫，更適合於非結構化數據存儲的資料庫，是一個高可靠性、高性能、面向列、可伸縮的分布式存儲系統，大數據開發需掌握HBase基礎知識、應用、架構以及高級用法等。

8.phoenix

phoenix是用Java編寫的基於JDBC API操作HBase的開源SQL引擎，其具有動態列、散列載入、查詢伺服器、追蹤、事務、用戶自定義函數、二級索引、命名空間映射、數據收集、行時間戳列、分頁查詢、跳躍查詢、視圖以及多租戶的特性，大數據開發需掌握其原理和使用方法。

9. Redis

Redis是一個key-value存儲系統，其出現很大程度補償了memcached這類key/value存儲的不足，在部分場合可以對關系資料庫起到很好的補充作用，它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客戶端，使用很方便，大數據開發需掌握Redis的安裝、配置及相關使用方法。

10. Flume

Flume是一款高可用、高可靠、分布式的海量日誌採集、聚合和傳輸的系統，Flume支持在日誌系統中定製各類數據發送方，用於收集數據;同時，Flume提供對數據進行簡單處理，並寫到各種數據接受方(可定製)的能力。大數據開發需掌握其安裝、配置以及相關使用方法。

11. SSM

SSM框架是由Spring、SpringMVC、MyBatis三個開源框架整合而成，常作為數據源較簡單的web項目的框架。大數據開發需分別掌握Spring、SpringMVC、MyBatis三種框架的同時，再使用SSM進行整合操作。

12.Kafka

Kafka是一種高吞吐量的分布式發布訂閱消息系統，其在大數據開發應用上的目的是通過Hadoop的並行載入機制來統一線上和離線的消息處理，也是為了通過集群來提供實時的消息。大數據開發需掌握Kafka架構原理及各組件的作用和使用方法及相關功能的實現!

13.Scala

Scala是一門多範式的編程語言，大數據開發重要框架Spark是採用Scala語言設計的，想要學好Spark框架，擁有Scala基礎是必不可少的，因此，大數據開發需掌握Scala編程基礎知識!

14.Spark

Spark是專為大規模數據處理而設計的快速通用的計算引擎，其提供了一個全面、統一的框架用於管理各種不同性質的數據集和數據源的大數據處理的需求，大數據開發需掌握Spark基礎、SparkJob、Spark RDD、spark job部署與資源分配、Spark shuffle、Spark內存管理、Spark廣播變數、Spark SQL、Spark Streaming以及Spark ML等相關知識。

15.Azkaban

Azkaban是一個批量工作流任務調度器，可用於在一個工作流內以一個特定的順序運行一組工作和流程，可以利用Azkaban來完成大數據的任務調度，大數據開發需掌握Azkaban的相關配置及語法規則。

16.Python與數據分析

Python是面向對象的編程語言，擁有豐富的庫，使用簡單，應用廣泛，在大數據領域也有所應用，主要可用於數據採集、數據分析以及數據可視化等，因此，大數據開發需學習一定的Python知識。

㈢ 什麼是大數據技術大數據的概念

大數據技術是指大數據的應用技術，涵蓋各類大數據平台、大數據指數體系等大數據應用技術。

大數據是指無法在一定時間范圍內用常規軟體工具進行捕捉、管理和處理的數據集合。是需要新處理模式才能具有更強的決策力、洞察發現力和流程優化能力的海量、高增長率和多樣化的信息資產。

隨著雲時代的來臨，大數據也吸引了越來越多的關注。分析師團隊認為，大數據通常用來形容一個公司創造的大量非結構化數據和半結構化數據，這些數據在下載到關系型資料庫用於分析時會花費過多時間和金錢。

大數據分析常和雲計算聯繫到一起，因為實時的大型數據集分析需要像MapRece一樣的框架來向數十、數百或甚至數千的電腦分配工作。

(3)linuxscala命令擴展閱讀：

大數據的三個層面：

1、理論，理論是認知的必經途徑，也是被廣泛認同和傳播的基線。在這里從大數據的特徵定義理解行業對大數據的整體描繪和定性；從對大數據價值的探討來深入解析大數據的珍貴所在；洞悉大數據的發展趨勢；從大數據隱私這個特別而重要的視角審視人和數據之間的長久博弈。

2、技術，技術是大數據價值體現的手段和前進的基石。在這里分別從雲計算、分布式處理技術、存儲技術和感知技術的發展來說明大數據從採集、處理、存儲到形成結果的整個過程。

3、實踐，實踐是大數據的最終價值體現。在這里分別從互聯網的大數據，政府的大數據，企業的大數據和個人的大數據四個方面來描繪大數據已經展現的美好景象及即將實現的藍圖。

參考資料來源：網路-大數據

㈣ 如何學好Scala

Spark也是基於JVM，我們構築分布式系統，藉助JVM，而不一定是Java語言。 Spark和消息中間件KAFKA等都是用Scala編寫的，學好Scala是掌握Spark的關鍵。
Scala基礎語法入門實戰
首先，參照相關攻略，在Linux下分別下載安裝Java、Scala，然後配置Java和Scala環境變數。安裝完畢，在終端敲入scala即可進入Scala命令行，如下所示：

root@Master:~# scala
Welcome to Scala version 2.10.4 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_66).
Type in expressions to have them evaluated.
Type :help for more information.

簡單測試
scala> 1+2
res0: Int = 3

scala> 1.5*2
res1: Double = 3.0

scala> 3*res1
res2: Double = 9.0

//按Tab鍵，命令自動補全
scala> res2.to
toByte toChar toDouble toFloat toInt toLong toShort toString

變數
var聲明可變變數；val聲明不可變變數。
val聲明的不可變變數，不希望數據被改變，RDD內部的數據都是不可變，所以在Spark中一般都是使用val。

//下面聲明了一個不可變變數result，result的值不可改變。
scala> val result=2+10
result: Int = 12

//假若修改result的值，會提示出錯，如下：
scala> result=13
<console>:8: error: reassignment to val
result=13

//var聲明可變變數：
scala> var name="Spark"
name: String = Spark

scala> name="Scala" //可以修改變數name的值
name: String = Scala

scala> name //name的值現在為Scala
res4: String = Scala

//val聲明不可變變數
//age被聲明為Int類型的不可變變數
scala> val age: Int=0
age: Int = 0

//聲明為String類型
scala> val name:String=null
name: String = null

一行代碼聲明多個變數
scala> val age1,age2,age3=0
age1: Int = 0
age2: Int = 0
age3: Int = 0

基本數據類型的自動轉換操作
Scala自己可以完成基本數據類型的自動轉換操作。

//輸入整數10，按Tab鍵盤，可以看見它本身的很多方法：
scala> 10.to
toByte toChar toDouble toFloat toInt toLong toShort toString

scala> 10.toString
res5: String = 10

scala> 0.to(5)
res6: scala.collection.immutable.Range.Inclusive = Range(0, 1, 2, 3, 4, 5)
給了我們一個不可變的集合，獲得的結果是：0~5，所以Scala一切皆對象！

Scala隱私轉換：
當類型本身沒有沒有這個方法，但是又需要調用這個方法時，內部就會自動觸發隱式轉換。剛才的示例中，Int本身沒有to這樣的方法，Scala引擎內部會隱式自動轉換成RichInt，就像上面0.to(5)這樣的調用，RichInt對象類型才有to這樣的函數。

scala> 1+1
res7: Int = 2

//因為Scala一切皆對象，所以以上示例又可以寫成：
scala> 1.+(1)
res9: Double = 2.0
這個示例，內部其實就是Int的一個隱式轉換，+是類的一個方法。

Scala沒有++、---操作運算：
scala> var age=10
age: Int = 10

// Scala沒有++、---操作運算
scala> age++
<console>:9: error: value ++ is not a member of Int
age++
^

//但是++運算可以用下面方式實現：
scala> age +=1

scala> age
res12: Int = 11

求最大、最小值
scala> min(20,4)
<console>:8: error: not found: value min
min(20,4)
^
該示例因為沒有導入庫，所以出錯。

scala> import scala.math._ //導入math庫
import scala.math._

scala> min(20,4)
res14: Int = 4

apply工廠構造實現方法
在Spark中，大量的實例的構造都是使用了apply方式。

scala> Array(1,2,3,4)
res15: Array[Int] = Array(1, 2, 3, 4)

scala> val array=Array(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)

//array是一個聲明整數類型的數組變數， 其實內部是自動調用了Array.apply方法，等同如下：
scala> val array = Array.apply(1,2,3,4)
array: Array[Int] = Array(1, 2, 3, 4)

條件控制、循環
// if表達式示例：
scala> if(age>=18) "成年人" else "小孩"
res16: String = 成年人

scala> val result=if(age>=18) "成年人" else "小孩"
result: String = 成年人

scala> result
res17: String = 成年人

scala> val result = if(age>=18){
| "alt"
| buffered=10
| buffered
| }
以上一個代碼塊，代碼塊後面有個返回值buffered，代碼塊的返回值就是最後一行的值。

列印值
scala> println("Spark") //輸出一行字元串並換行
Spark

scala> println("\nSpark") //換行，輸出一行字元串再換行。\n是換行轉義符。

Spark

scala> print("Spark") //輸出一行字元串，不換行
Spark
scala>

填充佔位符
scala> printf("%s是大數據框架的未來", "Spark") //%s是佔位符
Spark是大數據框架的未來

讀取內容
readLine用於讀取輸入的內容
scala> readLine //此時敲入Scala之後，然後回車
res28: String = Scala

scala> res28
res29: String = Scala

補充說明，readLine是一個方法，如果方法如果沒有參數，那麼可以不帶括弧，readLine()跟readLine效果一樣。

循環

//聲明一個可變變數，初始值為100
scala> var element=100
element: Int = 100

//while循環示例：
scala> while(element>90){
| println(element)
| element -= 1
| }
100
99
98
97
96
95
94
93
92
91

scala> 0 to element
res32: scala.collection.immutable.Range.Inclusive = Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90)

//for循環遍歷並列印
scala> for(i<-80 to element) println(i)
80
81
82
83
84
85
86
87
88
89
90

//循環並增加條件判斷
scala> for(i<-0 to element if i%2==0) print(i+" ")
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90

//for循環，並break退出
scala> import scala.util.control.Breaks._ //添加break引用
import scala.util.control.Breaks._

scala> for(i<-1 to 10){
| if(i==4) break
| println(i)
| }
1
2
3
scala.util.control.BreakControl

//循環，並return
scala> val n=5
n: Int = 5

scala> def f1:Any = {
| for(i <-1 to 10){
| if(i==n) return i
| println(i)
| }
| }
f1: Any

scala> f1
1
2
3
4
res1: Any = 5
解釋以上代碼塊，def是定義一個函數。f1就是一個函數。

二、 Scala函數入門實戰

函數示例
函數的定義使用def關鍵字，並且函數體最後有返回值。

//聲明了一個函數f3，兩個參數：param1是String類型，param2為Int類型。param2默認值為30，因為有了默認值，那麼在調用上可以不傳param2。
scala> def f3(param1:String, param2:Int=30) = param1 + param2
f3: (param1: String, param2: Int)String

//調用函數f3,傳入第一個參數param1值為Spark，沒有傳入第二個參數，默認為30。
scala> f3("Spark")
res4: String = Spark30

//帶名參數調用，即在函數調用時，顯示指定參數名，並不按順序傳入。
scala> f3(param2=100, param1="Scala")
res5: String = Scala100

//變長參數, 定義了一個sum函數，參數numbers是變成參數，即傳入的Int變數個數不定。在函數體中，對傳入的全部Int變數進行循環遍歷並累計求和，最後把結果返回。
scala> def sum(numbers: Int*)={var result=0; for(element<-numbers) result +=element; result}
sum: (numbers: Int*)Int

scala> sum(1,2,3,4,5,6,7,8,9,10)
res1: Int = 55

//下面示例是一個非常經典的語法
scala> sum(1 to 10: _*) // _* 表示提取裡面的每個元素, 然後作為變長參數傳遞
res3: Int = 55

過程
沒有返回值的函數就是過程。

//這是一個函數
scala> def morning(content:String) = "Good" + content
morning: (content: String)String

//這是一個過程
scala> def morning(content:String) { println( "Good" + content)}
morning: (content: String)Unit

//強制聲明一個過程
scala> def morning(content:String):Unit = "Good" + content
morning: (content: String)Unit

聲明lazy類型
scala> import scala.io.Source._ //導入引用庫
import scala.io.Source._

//聲明一個lazy類型的變數content，打開一個不存在的文件。
scala> lazy val content = fromFile("/root/txt")
content: scala.io.BufferedSource = <lazy>
以上示例執行不會出錯，表明content變數並沒有執行。

//如果去掉lazy關鍵字，那麼會出錯，提示文件不存在。
scala> val content = fromFile("/root/txt")
java.io.FileNotFoundException: /root/txt (No such file or directory)
at java.io.FileInputStream.open0(Native Method)
at java.io.FileInputStream.open(FileInputStream.java:195)
at java.io.FileInputStream.<init>(FileInputStream.java:138)

耗時的操作，在大型分布式系統中，比較常見。聲明lazy類型的變數，在需要的時候才去執行。

異常

//首先導入相關引用包
scala> import java.io._
import java.io._

scala>

//示例打開一個存在的文件，使用try…catch捕獲異常
scala> try{
| val content = fromFile("/root/.bashrc").mkString
| }catch{
| //case是一個偏函數
| case _: FileNotFoundException => println("Oh, file not found!")
| }finally{
| println("Ok!")
| }
Ok!

scala>

//示例打開一個不存在的文件，使用try…catch捕獲異常
scala> try{
| val content = fromFile("/root/.bashrc111").mkString
| }catch{
| //case是一個偏函數
| case _: FileNotFoundException => println("Oh, file not found!")
| }finally{
| println("Ok!")
| }
Oh, file not found!
Ok!

三、 Scala中Array、Map、Tuple實戰

Array

//聲明變數arr為Array整數類型的數組，包含5個元素。
scala> val arr= new Array[Int](5)
arr: Array[Int] = Array(0, 0, 0, 0, 0)

//訪問第三個元素
scala> arr(2)
res15: Int = 0

//修改第三個元素
scala> arr(2)=8

//再次查看arr數組，發現第三個元素值已經變成8了。
scala> arr
res17: Array[Int] = Array(0, 0, 8, 0, 0)

補充說明，剛才聲明arr數組變數時，所以把它聲明為val不可變變數，這只是表明arr的地址不可以變，但是數組裡面的元素還是可以變化的。

//在Spark中，更常見地創建數組是直接通過類名
scala> val arr1 = Array("Scala", "Spark")
arr1: Array[String] = Array(Scala, Spark)
該示例中，聲明arr1為數組變數時，沒有使用new關鍵字，也沒有指定String類型，系統默認根據元素值，自動推導出元素的類型為String。
沒有使用new關鍵字，其實它內部調用了apply方法， apply是工廠類構造器。等同於下面的寫法：
scala> val arr1 = Array.apply("Scala", "Spark")
arr1: Array[String] = Array(Scala, Spark)

//給Array增加元素。下面寫法會出錯，給arr1數組增加一個元素，比如：
scala> arr1(2)="Hadoop"
java.lang.: 2
at .<init>(<console>:16)
at .<clinit>(<console>)
……
如果需要給Array增加元素，那麼此時就應該使用ArrayBuffer類型。

ArrayBuffer
//首先導入庫
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

//定義一個ArrayBuffer類型的變數arrbuffer
scala> val arrbuffer=ArrayBuffer[Int]()
arrbuffer: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

//向arrbuffer中增加一個元素，值為10
scala> arrbuffer += 10
res23: arrbuffer.type = ArrayBuffer(10)

//向arrbuffer中增加多個元素
scala> arrbuffer += (11,1,3,5)
res25: arrbuffer.type = ArrayBuffer(10, 11, 1, 3, 5)

//查看arrbuffer的內容
scala> arrbuffer
res26: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5)

//向arrbuffer中增加一個數組
scala> arrbuffer ++= Array(1,2,3,4)
res27: arrbuffer.type = ArrayBuffer(10, 11, 1, 3, 5, 1, 2, 3, 4)

//截掉arrbuffer後面的3個元素
scala> arrbuffer.trimEnd(3)

//再次查看arrbuffer的內容，發現元素：2, 3, 4被截掉
scala> arrbuffer
res29: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5, 1)

//在第5個位置，插入元素值100
scala> arrbuffer.insert(5,100)

//查看arrbuffer的內容
scala> arrbuffer
res32: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 1, 3, 5, 100, 1)

//在第2個位置，插入多個元素：200,300,400
scala> arrbuffer.insert(2,200,300,400)

//查看arrbuffer的內容
scala> arrbuffer
res34: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 200, 300, 400, 1, 3, 5, 100, 1)

//從arrbuffer中移除第3個位置上的元素
scala> arrbuffer.remove(3)
res35: Int = 300 //被移除的值是300

//再次查看arrbuffer的內容，發現第3個位置上的元素300不見了。
scala> arrbuffer
res36: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 200, 400, 1, 3, 5, 100, 1)

//從arrbuffer中移除第2個位置開始的，3個元素，即：200, 400, 1
scala> arrbuffer.remove(2,3)

//再次查看arrbuffer的內容，發現三個元素：200, 400, 1 不見了。
scala> arrbuffer
res38: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(10, 11, 3, 5, 100, 1)

//可變數組變成不可變數組,此時arr2是一個不可變數組
scala> val arr2 = arrbuffer.toArray
arr2: Array[Int] = Array(10, 11, 3, 5, 100, 1)

// Array.toBuffer的結果變成一個ArrayBuffer
scala> arr2.toBuffer
res40: scala.collection.mutable.Buffer[Int] = ArrayBuffer(10, 11, 3, 5, 100, 1)

//遍歷一個數組：
scala> for(elem <- arr2) println(elem)
10
11
3
5
100
1

//遍歷數組時加上條件
scala> arr2
res42: Array[Int] = Array(10, 11, 3, 5, 100, 1)

//遍歷時的條件，跳過偶數位上的元素
scala> for(i <- 0 until (arr2.length, 2)) println(arr2(i))
10
3
100
此時列印出來的結果，跳過了元素：11、5、1

//從尾部開始遍歷
scala> for(i <- (0 until arr2.length).reverse) println(arr2(i))
1
100
5
3
11
10

//對數組進行排序
//導入排序包
scala> import scala.util.Sorting
import scala.util.Sortin

㈤ 大數據技術包括哪些

想要成為炙手可熱的大數據技術人才，這些大數據的核心技術一定要知曉！

一、大數據基礎階段
大數據基礎階段需掌握的技術有：Linux、Docker、KVM、MySQL基礎、Oracle基礎、MongoDB、redis以及hadoop maprece hdfs yarn等。
1、Linux命令
對於大數據開發通常是在Linux環境下進行的，相比Linux操作系統，Windows操作系統是封閉的操作系統，開源的大數據軟體很受限制，因此，想從事大數據開發相關工作，還需掌握Linux基礎操作命令
2、 Redis
Redis是一個key-value存儲系統，其出現很大程度補償了memcached這類key/value存儲的不足，在部分場合可以對關系資料庫起到很好的補充作用，它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客戶端，使用很方便，大數據開發需掌握Redis的安裝、配置及相關使用方法。
二、大數據存儲階段
大數據存儲階段需掌握的技術有：hbase、hive、sqoop等。
1、HBase
HBase是一個分布式的、面向列的開源資料庫，它不同於一般的關系資料庫，更適合於非結構化數據存儲的資料庫，是一個高可靠性、高性能、面向列、可伸縮的分布式存儲系統，大數據開發需掌握HBase基礎知識、應用、架構以及高級用法等。
2、Hive
Hive是基於Hadoop的一個數據倉庫工具，可以將結構化的數據文件映射為一張資料庫表，並提供簡單的sql查詢功能，可以將sql語句轉換為MapRece任務進行運行，十分適合數據倉庫的統計分析。對於Hive需掌握其安裝、應用及高級操作等。
三、大數據架構設計階段
大數據架構設計階段需掌握的技術有：Flume分布式、Zookeeper、Kafka等。
1、Kafka
Kafka是一種高吞吐量的分布式發布訂閱消息系統，其在大數據開發應用上的目的是通過Hadoop的並行載入機制來統一線上和離線的消息處理，也是為了通過集群來提供實時的消息。大數據開發需掌握Kafka架構原理及各組件的作用和使用方法及相關功能的實現！
2、Flume
Flume是一款高可用、高可靠、分布式的海量日誌採集、聚合和傳輸的系統，Flume支持在日誌系統中定製各類數據發送方，用於收集數據;同時，Flume提供對數據進行簡單處理，並寫到各種數據接受方(可定製)的能力。大數據開發需掌握其安裝、配置以及相關使用方法。
3、ZooKeeper
ZooKeeper是Hadoop和Hbase的重要組件，是一個為分布式應用提供一致性服務的軟體，提供的功能包括：配置維護、域名服務、分布式同步、組件服務等，在大數據開發中要掌握ZooKeeper的常用命令及功能的實現方法。
四、大數據實時計算階段
大數據實時計算階段需掌握的技術有：Mahout、Spark、storm。
1、Spark
Spark是專為大規模數據處理而設計的快速通用的計算引擎，其提供了一個全面、統一的框架用於管理各種不同性質的數據集和數據源的大數據處理的需求，大數據開發需掌握Spark基礎、SparkJob、Spark RDD、spark job部署與資源分配、Spark shuffle、Spark內存管理、Spark廣播變數、Spark SQL、Spark Streaming以及Spark ML等相關知識。
2、storm
Storm為分布式實時計算提供了一組通用原語，可被用於「流處理」之中，實時處理消息並更新資料庫。這是管理隊列及工作者集群的另一種方式。Storm可以方便地在一個計算機集群中編寫與擴展復雜的實時計算，Storm用於實時處理，就好比 Hadoop 用於批處理。Storm保證每個消息都會得到處理，而且它很快——在一個小集群中，每秒可以處理數以百萬計的消息。
五、大數據數據採集階段
大數據數據採集階段需掌握的技術有：Python、Scala。
1、Python與數據分析
Python是面向對象的編程語言，擁有豐富的庫，使用簡單，應用廣泛，在大數據領域也有所應用，主要可用於數據採集、數據分析以及數據可視化等，因此，大數據開發需學習一定的Python知識。
2、Scala
Scala是一門多範式的編程語言，大數據開發重要框架Spark是採用Scala語言設計的，想要學好Spark框架，擁有Scala基礎是必不可少的，因此，大數據開發需掌握Scala編程基礎知識！
以上只是一些簡單的大數據核心技術總結，比較零散，想要學習大數據的同學，還是要按照一定到的技術路線圖學習！