推荐书籍，快学scala
val str="i love scala" //编译器自动确定类型,使用val定义的变量值是不可变的，相当于java里用final修饰的变量
val i = 1
var s="hello" //使用var定义的变量是可变的，再scala中鼓励使用val
val stri: String ="alex" //scala编译器会自动推断变量的类型，必要的时候可以指定类型，变量名在前，类型在后
常用的变量类型： Byte，Char，Short，Int，Long，Float，Double，Boolean
if例子：val y = if(x >0) 1 else -1
if例子:val z=if(x>0) 1 else "error" //在未赋值时，可以是数值，也可以是字符串。但是他的类型变成了"Any"
if例子：val m =if(x >2) 1 //如果x不大于2，那么是未赋值。返回值是m: AnyVal=()。在scala中每个表达式都有值，scala仲有个Unit类，写做()，相当于java中的void
object 单例对象
class 类
trait 相当于java中的接口
块表达式：
object BlockExpressionDemo {
def main(args: Array[String]): Unit = {
val x=0
val result={ //这是一个块表达式，块中最后一个表达式的值就是块的值
if(x<0){
-1
}else if(x>=1){
1
}else {
"error"
}
}
println(result);
}
}
数组例子：
val arr=Array(1,2,3)
val arr2=(1 to 10)
val arr3=Array(1 to 10) //这样是错的，
arr(1)=100
for循环：
1 to 10 //会返回一个scala的Range(1,2,3,4,5,6,7,8,9,10)
for(i <- 1 to 10){
println(i)
}
val a1=(1 to 9)
for(i <- 0 until a1.length) println(i) //打印出来的0-8
高级for循环: //注意:if前面没有分号
for(i<- 1 to 3; j <- 1 to 3 if i!=j){
print((10 * i + j )+" ")
}
for推导式
val v = for (i <- 1 to 10) yield i*10 //yield生成一个新的集合数组
println(v)//会发现v是一个新集合 Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
map例子：
val z=(1 to 10).map(_*10) //也可以写成 (1.to(10).map(_*10),也是返回一个Vector数组
println(z)
val f1=(x:Int) => x * 10
val r= 1 to 10
r.map(f1)
filter例子:
val a1=(1.to(9))
val a2=a1.filter(_%2==0) //filter也是返回一个新数组
until方法：
val a1=(1 to 9)
0 util a1.legnth
for(i <- 0 until a1.length) println(i) //打印出来的0-8
定义方法和函数,函数和方法是有区别的，函数可以作为一个值传到方法里
方法：
def m1(x: Int, y: Int) : Int = x * y //x: Int 参数列表 : Int 方法返回值类型 方法的返回值类型可以不写，编译器可以自动推断，但是对于递归函数，必须指定返回类型
调用val r=m1(3,5)
定义没有返回值的方法：
def m2(name:String): Unit ={
println(name)
}
val v=m2("alex")
print(v)
匿名函数：
val abc=(x:Int,y:Int) => x+y
val func=(x:Int,y:Double) => (y,x) //返回值是一个元组
val func2:(Int,Double) => (Double,Int) = {(a,b) => (b,a) } //(a,b)代表前面(Int,Double)的局部变量 和上面例子的效果一样
简单版匿名函数传入方法的例子：
val f1=(x:Int) => x * 10
val f2=(x:Int) => x+10
val r= 1 to 10
r.map(f1)
r.map(f2)
r.map((x:Int) => x*100) //直接定义一个匿名函数
r.map(x => x*100) //同上面一样效果，更简洁
r.map(_*100) //同上面一样效果，最简洁
val arr=1 to 9
val r1=arr.map(x=>x*5) //产生一个新数组r1
val r2=arr.map(x=>x-1) //产生一个新数组r2
println(r1) //打印数组
println(r1.toBuffer) //把r1变成一个ArrayBuffer
完整版匿名函数传入方法的例子:
object HelloScala{
def main(args: Array[String]): Unit = {
println(m1(func))
}
val func = (x:Int) => x*10
def m1(f:Int => Int) : Int={ //表示需要传入一个Int参数，返回一个Int值，
//在方法体里调用函数
f(3)
}
}
高级版定义匿名函数的例子：
val func:Int => String = { x => x.toString } //传入一个Int =>是返回值，返回一个String 后面必须有大括号函数体 要有一个变量x接收传进来Int,这个x是一个局部变量
调用func(10) 就返回一个String
将方法转换成函数（神奇的下划线）
def m2(x:Int,y:Int) :Int =x+y //定义一个方法
scala> def m2(x:Int,y:Int) :Int =x+y
m2: (x: Int, y: Int)Int
val f2=(a:Int,b:Int) => a+b //定义一个函数
val f3=m2 _ //把方法m2变成了函数
数组，映射，元组，集合
数组：定长数组和变长数组
val arr=new Array[Int](10) //装Int的数组，长度为10，里面值是0
println(arr) //直接打印定长数组，内容为数组的hashcode值
println(arr.toBuffer) //将数组转换成数组缓冲，就可以看到原数组中的内容了，toBuffer会将数组转换成数组缓冲
arr(0)=1 //赋值
arr(1)=2
val arr1=Array(1,3,4,5,6) //定义一个长度为5的数组
val arr2=Array[Int](10) //这里没new,这样只创建了一个长度为1的数组，里面只有一个值为10
println(arr2.toBuffer) //ArrayBuffer(10),长度为1的数组，里面只有一个值为10
变长数组（数组缓冲）：
ArrayBuffer，如果想使用数组缓冲，需要导入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(0,-1,0) //在数组某个位置插入元素用insert ，这里在数组的0下标上插入了两个数字-1和0
ab.remove(8,2) //删除数组某个位置的元素用remove，这里删除了下表8开始的2个元素
遍历数组：
1.增强for循环
val arr=Array(1,2,3,4,5,6)
for(i <- arr)
println(i)
2.好用的uttil会生成脚标，0 until 10 包含0不包含10
for(i <- (0 until arr.length).reverse) //reverse反转
println(arr(i))
val a1=ArrayBuffer(8,2,3)
a1.map(print)
a1.map(println)
a1.map(println(_))
数组的转换：
yield关键字将原始的数组进行转换会产生一个新的数组
val a =Array(1,2,3,4,5)
for(i<- a) yield i * 10
a.map(x=>x*10) //效果和上面相同
a.map((x:Int)=>x * 10) //效果和上面相同
a.map( _ * 10) //效果和上面相同
数组转换小例子：
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 //第一种方法
arr.filter((x:Int) => x%2 ==0 ) //传进来一个Int,返回一个布尔值 , 最后结果是2，4，6，8
arr.filter(x=> x %2 ==0) //上面的简单版，最后结果是2，4，6，8
arr.filter( _ % 2 ==0) //更简洁版，最后是2，4，6，8
arr.filter( _ % 2 ==0).map( _ * 10) //正确答案
其他例子：arr.sum //返回值45
val arr=Array(2,5,1,4,7,3)
arr.sorted //返回值1，2，3，4，5，6，7
arr.sorted.reverse //返回值7，6，5，4，3，2，1
arr.sortBy(x => x) //返回值1，2，3，4，5，6，7
arr.sortWith( _>_ ) //返回值7，6，5，4，3，2，1 ，从大到小
arr.sortWith( _<_ ) //返回值1，2，3，4，5，6，7,从小到大
arr.sortWith((x,y) => x< y ) //返回值1，2，3，4，5，6，7
映射：
构建映射：
val m=Map("a" -> 1, "b" -> 2) //创建的时候是immutable.Map 不可改变
m("a") //访问
m("a") =2 //报错，不可改变，
import scala.collection.mutable.Map
val mm=Map("i"->1, "j" ->2) //创建的是mutable的map，可以改变
mm("i")=10 //可以
mm("k")=20 //可以
mm+=("o" -> 6) //可以
mm+=(("o",6)) //可以
import java.util.HashMap //可以引入java的包
val hm= new HashMap()
val m = Map(("a",1) ,("b" ,2)) //其实映射里装的是元组,都是对偶元组
访问映射：
m.getOrElse("c",0) //如果m里面没有c，不会报错 ，给他个0
元组：
val t=(1,"spark",2.0) //返回一个(Int, String, Double)
访问：
val r=t._2 //取出spark
val pair=("t",5) //定义一个对偶元组
val m = Map(("a",1) ,("b" ,2))
把上面的pari装入m
m+= pair //res5: m.type = Map(t -> 5, b -> 2, a -> 1)
m+=(("y",6),("z",3)) // res6: m.type = Map(z -> 3, t -> 5, b -> 2, y -> 6, a -> 1)
特殊的例子：
val t=("a", 1, 2.0)
t._2
res0: Int = 1
scala> t._1
res1: String = a
val t,(x,y,z)=("a",1, 2.0)
t: (String, Int, Double) = (a,1,2.0)
x: String = a
y: Int = 1
z: Double = 2.0
scala> x
res2: String = a
将对偶的集合转换成映射：
scala> val arr=Array(("a",1),("b",2))
arr: Array[(String, Int)] = Array((a,1), (b,2))
scala> arr.toMap //转换成了map
res3: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2)
拉链操作：
scala> val a=Array("a","b","c")
a: Array[String] = Array(a, b, c)
scala> val b=Array(1,2,3)
b: Array[Int] = Array(1, 2, 3)
scala> a.zip(b)
res4: Array[(String, Int)] = Array((a,1), (b,2), (c,3))
如果拉链多出来一截：
scala> val b=Array(1,2,3,4)
b: Array[Int] = Array(1, 2, 3, 4)
scala> a.zip(b)
res5: Array[(String, Int)] = Array((a,1), (b,2), (c,3)) //多出来的一截自动没有
集合：
集合有三大类：序列Seq，集Set，映射Map，所有集合都扩展子Iterable特质。集合有可变和不可变的两种类型。
val lst=List(1,3,4,5,6)
val list=List(1,2,3)
list(0) //取值
list(0)=10 //报错，不可变
导包：
import scala.collection.mutable.ListBuffer
val lb=ListBuffer(1,2,3)
lb(1)=200 //可以改变值了
scala> lb
res7: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 200, 3)
scala> lb.map(_ * 10) //新生成一个List
res8: scala.collection.mutable.ListBuffer[Int] = ListBuffer(10, 2000, 30)
val lst1=List(1,2,3)
val lst2=0::lst1 //将0插入到lst1的前面生成一个新的List
val lst3=lst1.::(0) //效果同上
val lst4=0+:lst1 //效果同上
val lst5=lst1.+:(0) //效果同上
val lst6=lst1 :+3 //将一个元素添加到lst1的后面产生一个新的集合
val lst0=ListBuffer[Int](1,2,3)
val lst1 = new ListBuffer[Int]
lst1 +=4 //追加4
lst1.append(5) //追加5
lst1 +=(8,9) //追加多个元素
lst2 = ListBuffer(10) //创建一个新集合
lst1 ++=lst2 //把lst2加到lst1里 和 ArrayBuffer里面一样
val lst3=lst1++lst2 //两集合相加，并生成一个新集合
List小例子：
val lst=List(1,3,2,7,5,9,6,4,8) //创建一个List
val lst1=lst.sorted //从大到小排序
val it = lst1.grouped(5) //创建了一个iterator
val lst2=it.toList //查看it里的两个集合，将iterator转换成List, lst2里有两个List，大List套了两个小List
lst2(0) //访问第一个list
val lst3=lst2.flatten //把lst2中的两个小list，平铺成一个大List
例子：单机版WordCount
val lines =List("hello tom hello jerry","hello tom kitty hello hello")
lines.map(_.split(" ")) //用空格来切 ，结果是res35: List[Array[String]] = List(Array(hello, tom, hello, jerry), Array(hello, tom, kitty, hello, hello))
lines.map(_.split(" ")).flatten //上面切完以后，用flatten，编程一个大集合 res36: List[String] = List(hello, tom, hello, jerry, hello, tom, kitty, hello, hello)
//比上面更好的方法
val words=lines.flatMap(_.split(" ")) //flatMap想当与先做了map再做flat操作。
val wordsAndOne = words.map((_,1)) //返回一个List，list里装的是对偶元组。wordsAndOne: List[(String, Int)] = List((hello,1), (tom,1), (hello,1), (jerry,1), (hello,1), (tom,1), (kitty,1), (hello,1), (hello,1))
val grouped = wordsAndOne.groupBy(_._1) //第一个_ 代表每个元组例如(hello,1), 第二个_1代表每个元组里的第一个元素，例如hello。 grouped: scala.collection.immutable.Map[String,List[(String, Int)]] = Map(tom -> List((tom,1), (tom,1)), kitty -> List((kitty,1)), jerry -> List((jerry,1)), hello -> List((hello,1), (hello,1), (hello,1), (hello,1), (hello,1)))
//不用执行，可以看看 val result =grouped.map(_._1) //返回一个List。请比较一下val result =grouped.map(_._2) 的区别。 还有，请试试val result=grouped.keys 这个返回是一个Set(tom,kitty,jerry,hello)
result: scala.collection.immutable.Iterable[String] = List(tom, kitty, jerry, hello)
val result = grouped.map(t => (t._1,t._2.size)) //t是对偶元组tom->List((tom,1),(tom,1)) t._1是key，就是tom， t._2是List，然后取他的size。 最后结果result: scala.collection.immutable.Map[String,Int] = Map(tom -> 2, kitty -> 1, jerry -> 1, hello -> 5)
val finalResult = result.toList.sortBy(_._2) // _是元组，按照次数排序。升序finalResult: List[(String, Int)] = List((kitty,1), (jerry,1), (tom,2), (hello,5))
val finalResult = result.toList.sortBy(_._2).reverse //降序
val finalResult = result.toList.sortBy(_._2).reverse.filter(_._2>1) //过滤1次以上的数据
finalResult: List[(String, Int)] = List((hello,5), (tom,2))
//上面的简化版
val lines =List("hello tom hello jerry","hello tom kitty hello hello")
val grouped = lines.flatMap(_.split(" ")).map((_,1)).groupBy(_._1)
val result=grouped.mapValues(_.size) // _代表每个List，例如List((tom,1),(tom,1)) mapValues不动key，所以还是tom,kitty,jerry等，统计的是values，也就是每个List
fold例子：
val a=Array(1,2,3,4,5,6)
a.sum //21
a.reduce (_+_) //reduce把里面内容进行汇总 ,结果21 (((1+2)+3)+4) 从左开始加 默认调用reduceLeft
a.reduce(_-_) //-19
a.par //返回一个可以并行化操作的集合res0: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4, 5, 6)
a.par.reduce(_+_) //21
fold(10)(_+_) //蜕化。可以传2个参数。
a.fold(10)(_+_) //31 给了个初始值10，
fold也支持并行化计算
a.par.fold(10)(_+_) //61
Set：
不可变的Set: import scala.collection.immutable.HashSet
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)
可变的Set:
import scala.collection.mutable
object MutSetDemo 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：也分为可变和不可变
object MutMapDemo 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)
}
object伴生对象，里面一般存放静态对象，类似于java中的静态变量，静态方法。
scala的hello world
object HelloScala { //object 伴生对象，单例对象
def main(args: Array[String]) { //所有定义在object里的方法，都是静态方法，相当于java中所有方法加上了static
println("hello scala,I love u")
}
}
scala里的类
//在Scala中，类并不用声明为public。
//Scala源文件中可以包含多个类，所有这些类都具有公有可见性。
class Person {
//用val修饰的变量是只读属性，有getter但没有setter
//（相当与Java中用final修饰的变量）
val id = "9527"
//用var修饰的变量既有getter又有setter
var age: Int = 18
//类私有字段,只能在类的内部使用
private var name: String = "唐伯虎"
//对象私有字段,访问权限更加严格的，Person类的方法只能访问到当前对象的>字段
private[this] val pet = "小强"
}
构造器:
注意：主构造器会执行类定义中的所有语句
/**
*每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起
*/
class Student(val name: String, val age: Int){
//主构造器会执行类定义中的所有语句
println("执行主构造器")
try {
println("读取文件")
throw new IOException("io exception")
} catch {
case e: NullPointerException => println("打印异常Exception : " + e)
case e: IOException => println("打印异常Exception : " + e)
} finally {
println("执行finally部分")
}
private var gender = "male"
//用this关键字定义辅助构造器
def this(name: String, age: Int, gender: String){
//每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始
this(name, age)
println("执行辅助构造器")
this.gender = gender
}
}
/**
*构造器参数可以不带val或var，如果不带val或var的参数至少被一个方法所使用，
*那么它将会被提升为字段
*/
//在类名后面加private就变成了私有的
class Queen private(val name: String, prop: Array[String], private var age: Int = 18){
println(prop.size)
//prop被下面的方法使用后，prop就变成了不可变得对象私有字段，等同于private[this] val prop
//如果没有被方法使用该参数将不被保存为字段，仅仅是一个可以被主构造器中的代码访问的普通参数
def description = name + " is " + age + " years old with " + prop.toBuffer
}
object Queen{
def main(args: Array[String]) {
//私有的构造器，只有在其伴生对象中使用
val q = new Queen("hatano", Array("蜡烛", "皮鞭"), 20)
println(q.description())
}
}
6.2.1. 单例对象
在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的
1.存放工具方法和常量
2.高效共享单个不可变的实例
3.单例模式
ackage cn.itcast.scala
import scala.collection.mutable.ArrayBuffer
/**
* Created by ZX on 2015/11/14.
*/
object SingletonDemo {
def main(args: Array[String]) {
//单例对象，不需要new，用【类名.方法】调用对象中的方法
val session = SessionFactory.getSession()
println(session)
}
}
object SessionFactory{
//该部分相当于java中的静态块
var counts = 5
val sessions = new ArrayBuffer[Session]()
while(counts > 0){
sessions += new Session
counts -= 1
}
//在object中的方法相当于java中的静态方法
def getSession(): Session ={
sessions.remove(0)
}
}
class Session{
}
6.2.2. 伴生对象
在Scala的类中，与类名相同的对象叫做伴生对象，类和伴生对象之间可以相互访问私有的方法和属性
package cn.itcast.scala
/**
* Created by ZX on 2015/11/14.
*/
class Dog {
val id = 1
private var name = "itcast"
def printName(): Unit ={
//在Dog类中可以访问伴生对象Dog的私有属性
println(Dog.CONSTANT + name )
}
}
/**
* 伴生对象
*/
object Dog {
//伴生对象中的私有属性
private val CONSTANT = "汪汪汪 : "
def main(args: Array[String]) {
val p = new Dog
//访问私有的字段name
p.name = "123"
p.printName()
}
}
6.2.3. apply方法
通常我们会在类的伴生对象中定义apply方法，当遇到类名(参数1,...参数n)时apply方法会被调用
package cn.itcast.scala
/**
* Created by ZX on 2015/11/14.
*/
object ApplyDemo {
def main(args: Array[String]) {
//调用了Array伴生对象的apply方法
//def apply(x: Int, xs: Int*): Array[Int]
//arr1中只有一个元素5
val arr1 = Array(5)
println(arr1.toBuffer)
//new了一个长度为5的array，数组里面包含5个null
var arr2 = new Array(5)
}
}
6.2.4. 应用程序对象
Scala程序都必须从一个对象的main方法开始，可以通过扩展App特质，不写main方法。
package cn.itcast.scala
/**
* Created by ZX on 2015/11/14.
*/
object AppObjectDemo extends App{
//不用写main方法
println("I love you Scala")
}