1、Scala的特点及下载安装
- Scala是一种多范式的编程语言,其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台(Java虚拟机),并兼容现有的Java程序。
优雅:这是框架设计师第一个要考虑的问题,框架的用户是应用开发程序员,API是否优雅直接影响用户体验。
速度快:Scala语言表达能力强,一行代码抵得上Java多行,开发速度快;Scala是静态编译的,所以和JRuby,Groovy比起来速度会快很多。开发效率快
能融合到Hadoop生态圈:Hadoop现在是大数据事实标准,Spark并不是要取代Hadoop,而是要完善Hadoop生态。JVM语言大部分可能会想到Java,但Java做出来的API太丑,或者想实现一个优雅的API太费劲。- 安装
(2)IDEA安装Scala
1.安装IDEA,点击下一步即可。由于我们离线安装插件,所以点击Skip All and Set Defaul
2.下载IEDA的scala插件,地址http://plugins.jetbrains.com/?idea_ce3.安装Scala插件:Configure-> Plugins -> Install plugin from disk -> 选择Scala插件-> OK -> 重启IDEA
至此安装成功,新建Scala项目即可进行使用
2、Scala的基本语法
(1)变量
1)我们修饰符有两个关键字:var val
Var修饰的:这个变量的值是可以修改的。
Val修饰的:这个边浪的是是不可以修改的。
2)声明:先写变量名,再写数据类型(跟java刚好相反)
我们可以不用写数据类型,如果不写,可以进行自动类型推断。
//使用val定义的变量值是不可变的,相当于java里用final修饰的变量
val i = 1
//使用var定义的变量是可变的,在Scala中鼓励使用val
var s = "hello"
//Scala编译器会自动推断变量的类型,必要的时候可以指定类型
//变量名在前,类型在后
val str: String = "world"
Scala: == equals 比较的是指,如果比较引用地址:eq ne
(2)数据类型
Scala和Java一样,有7种数值类型Byte、Char、Short、Int、Long、Float和Double和一个Boolean类型
注:Scala 没有象java 有基本数据类型和包装类型之分。认为所有的都是基本数据类型
(3)条件表达式
object ConditionTest {
def main(args: Array[String]) {
val x = 1
//判断x的值,将结果赋给y
val y = if (x > 0) 1 else -1
//打印y的值
println(y)
//当表达式有多条语句,需要加{},最后一条语句作为返回值
val a = if(3 > 2){
va了 b =3+3
b*3
}else{
"fa"
}
//a=18
//支持混合类型表达式
val z = if (x > 1) 1 else "error"
//打印z的值
println(z)
//如果缺失else,相当于if (x > 2) 1 else ()
val m = if (x > 2) 1
println(m)
//在scala中每个表达式都有值,scala中有个Unit类,写做(),相当于Java中的void
val n = if (x > 2) 1 else ()
println(n)
//if和else if
val k = if (x < 0) 0 else if (x >= 1) 1 else -1
println(k)
}
}
总结:
1) if条件语句是有返回值的
2) 返回值的类型,可以进行自动的推断。
3) else if的使用方式跟java是一模一样的。
//在scala中{}中课包含一系列表达式,块中最后一个表达式的值就是块的值
总结:
在我们的scala,最后一行代码就是我们的返回值。
Java:return
Scala:把需要返回的东西放到最后一行就可以了。
(4)循环
1、
1)while循环跟java循环使用下来是一样的。
2)需要注意的是scala里面不支持 ++ --的操作,但是支持+= -=操作。
2、
1)while循环跟java循环使用下来是一样的。
2)需要注意的是scala里面不支持 ++ --的操作,但是支持+= -=操作。
object ForTest {
def main(args: Array[String]) {
//for(i <- 表达式),表达式1 to 10返回一个Range(区间)
//每次循环将区间中的一个值赋给i
for (i <- 1 to 10)
println(i)
//for(i <- 数组)
val arr = Array("a", "b", "c")
for (i <- arr)
println(i)
//高级for循环
//每个生成器都可以带一个条件(前后可以都有),注意:if前面没有分号
for(i <- 1 to 3 ; j <- 1 to 3 if i != j)
print((10 * i + j) + " ")
println()
//for推导式:如果for循环的循环体以yield开始,则该循环会构建出一个集合
//每次迭代生成集合中的一个值
val v = for (i <- 1 to 10) yield i * 10
println(v)
}
}
1:for( i <- 数组/集合/表达式)
2: 0 to 2 结果:0 1 2 0 until 2 结果是:0 1
3: 关键字yield 如果我们要向使用for循环体构建出来一个新的集合,那么就使用这个关键字。
(5)调用方法和函数
Scala中的+ - * / %等操作符的作用与Java一样,位操作符 & | ^ >> <<也一样。只是有
一点特别的:这些操作符实际上是方法。例如:
a + b
是如下方法调用的简写:
a.+(b)
a 方法 b可以写成 a.方法(b)
方法定义:
方法的返回值类型可以不写,编译器可以自动推断出来,但是对于递归函数,必须指定返回类型
如果不写等号,代表没有返回值。方法体用{}包裹
方法函数:
![](https://i-blog.csdnimg.cn/blog_migrate/79fc2950f71dd226450deb916b5f67cd.png)
在函数式编程语言中,函数是“头等公民”,它可以像任何其他数据类型一样被传递和操作
![](https://i-blog.csdnimg.cn/blog_migrate/6f6f534c89e862aae16f556ea433631f.png)
(6)数组、映射、元组、集合
<1>数组
import scala.collection.mutable.ArrayBuffer
object ArrayTest {
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(8, 2)
println(ab)
}
}
object ForArrayTest {
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))
}
}
object ArrayYieldTest {
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)
}
yield 是for循环有返回值的关键字
<2>映射
创建:
获取值
修改值
也可以用scores("aa")=b的方式
<3>元组
创建
获取值
将对偶元组转换为映射
合并两个元组,使其一一对应zip--拉链操作
注意:如果两个数组的元素个数不一致,拉链操作后生成的数组的长度为较小的那个数组的元素个数
<4>集合
Scala的集合有三大类:序列Seq、集Set、映射Map,所有的集合都扩展自Iterable特质
在Scala中集合有可变(mutable)和不可变(immutable)两种类型,immutable类型的集合初始化后就不能改变了(注意与val修饰的变量进行区别)
Arry 序列(list)
不可变的序列 import scala.collection.immutable._
在Scala中列表要么为空(Nil表示空列表)要么是一个head元素加上一个tail列表。
9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
注意::: 操作符是右结合的,如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
List
object ImmutListTest {
def main(args: Array[String]) {
//创建一个不可变的集合
val lst1 = List(1,2,3)
//将0插入到lst1的前面生成一个新的List
val lst2 = 0 :: lst1
val lst3 = lst1.::(0)
val lst4 = 0 +: lst1
val lst5 = lst1.+:(0) (可以忽略)
//将一个元素添加到lst1的后面产生一个新的集合
val lst6 = lst1 :+ 3
val lst0 = List(4,5,6)
//将2个list合并成一个新的List
val lst7 = lst1 ++ lst0
//将lst0插入到lst1前面生成一个新的集合
val lst8 = lst1 ++: lst0
//将lst0插入到lst1前面生成一个新的集合
val lst9 = lst1.:::(lst0)
println(lst9)
}
}
import scala.collection.mutable.ListBuffer
object MutListTest 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
}
Set
import scala.collection.immutable.HashSet
object ImmutSetTest extends App{
val set1 = new HashSet[Int]()
//将元素和set1合并生成一个新的set,原有set不变
val set2 = set1 + 4
//set中元素不能重复
val set3 = set1 ++ Set(5, 6, 7)
val set0 = Set(1,3,4) ++ set1
println(set0.getClass)
}
import scala.collection.mutable
object MutSetTest extends App{
//创建一个可变的HashSet
val set1 = new mutable.HashSet[Int]()
//向HashSet中添加元素
set1 += 2
//add等价于+=
set1.add(4)
set1 ++= Set(1,3,5)
println(set1)
//删除一个元素
set1 -= 5
set1.remove(2)
println(set1)
}
Map
import scala.collection.mutable
object MutMapTest extends App{
val map1 = new mutable.HashMap[String, Int]()
//向map中添加数据
map1("spark") = 1
map1 += (("hadoop", 2))
map1.put("storm", 3)
println(map1)
//从map中移除元素
map1 -= "spark"
map1.remove("hadoop")
println(map1)
}