标签：产生 orm 推荐 多个 内容 添加元素 一点 包含 匿名
scala 基本语法
1.声明变量
(1)val i = 1 使用val声明的变量值是不可变的，相当于java里final修饰的变量，推荐使用。
(2)var i = "hello" 使用var声明的变量值是可变的
(3)val s = "hi" scala编译器会自动推断变量的类型，必要的时候可以指定类型，变量名在前，类型在后
2.常用的类型
Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型
3.条件表达式
(1)if else
val s = if(x>1)1 else 2
(2)支持混合类型表达式
val s = if(x>1)1 else "Hello"
(3)在scala中每个表达式都有值，scala中有个Unit类，写作（），相当于java中的void
val n = if(x>2)1 else()
(4)if else if else
val s = if(x>1)1 else if(x=0)0 else -1
4.循环
（1）for循环
for(i <- 1 to 10)
println(i)
1 to 10 表达式1 to 10返回一个Range（区间）所有1到10之间的数值，println打印i的值
（2）高级for循环
for（i <- 1 to 3;j <-1 to 3 if i!=j）{
print(i+j)
}
先会循环i的值（i=1）在循环j的值，将j的值全部循环完毕后，再此循环i的值（i=2），在此循环j的所有的值
（3）for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
val v = for (i <- 1 to 10) yield i * 10
println(v)
5.调用方法和函数
Scala中的+ - * / %等操作符的作用与Java一样，位操作符 & | ^ >> <<也一样。只是有
一点特别的：这些操作符实际上是方法。例如：
a + b
是如下方法调用的简写：
a.+(b)
a 方法 b可以写成 a.方法(b)
6.定义方法
def m（x: Int，y: Int）：Int{
x*y
}
def 定义方法的关键字
m 定义方法的名称
x: Int，y: Int 定义方法的参数列表，两个Int类型的参数
：Int 方法返回的参数类型
x*y 方法的具体执行内容，定义对参数x和y的操作
方法的返回值类型可以不写，编译器可以自动推断出来，但是对于递归函数，必须指定返回类型
7.定义函数
val f1=(x:Int, y_int )=>{x*y}
8.将方法转换成函数
val f2 = m _
9.定长数组
（1）初始化一个长度为8的定长数组，其所有元素均为0
val arr1 = new ArrayInt
（2）直接打印定长数组，内容为数组的hashcode值
println(arr1)
（3）将数组转换成数组缓冲，就可以看到原数组中的内容了 ，toBuffer会将数组转换长数组缓冲
println(arr1.toBuffer)
（4）如果不new，相当于调用了数组的apply方法，直接为数组赋值
初始化一个长度为1的定长数组
val arr = ArrayInt
（5）定义一个长度为3的定长数组
val arr3 = Array("hadoop", "storm", "spark")
(6)使用()来访问元素
println(arr3(2))
10.变长数组（数组缓冲）
(1)定义如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
val ab = ArrayBuffer[Int]()
(2)向数组缓冲的尾部追加一个元素
ab += 1
(3)追加多个元素
ab += (2, 3, 4, 5)
(4)追加一个数组++=
ab ++= Array(6, 7)
(5)追加一个数组缓冲
ab ++= ArrayBuffer(8,9)
(6)在数组某个位置插入元素用insert
ab.insert(0, -1, 0) 在数组0的位置前面插入-1和0
（7）删除数组某个位置的元素用remove
ab.remove(3, 2) 移除数组3位置的后面两个元素
11.循环数组
（1）用until会生成脚标，0 until 10 包含0不包含10
0 until 10
res6: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
（2）for循环
val arr = Array(1,2,3,4,5,6,7,8)
for(i <- arr)
println(i)
i接收arr循环过程中的每一个元素
（3）用until生产一个Range，使用reverse是将前面生成的Range反转
for(i <- (0 until arr.length).reverse)
println(arr(i))
12.数组转换
（1）val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
arr.map(_ *2)
转换成为一个新的数组，每个元素乘以2，map是循环得到每个元素，_ 是对每个循环中元素的匿名引用
（2）filter是过滤，接收一个返回值为boolean的函数
val r = arr.filter(_ % 2 == 0)
过滤出所有的偶数
13.数组常用算法
(1)数组求和(arr为自定义的一个数组)
arr.sum
(2)数组最大值
arr.max
(3)数组排序 （默认是正序）
arr.sorted
14.映射（java中的Map）
在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变
不可变map
(1)构建映射
用箭头的方式构建Map
val m = Map("a" -> 11,"b" ->12 ,"c" -> 13)
用元组的方式构建Map
val m = Map(("a",11),("b",12),("c",13))
(2)获取映射中的值
m("a")
(3)getOrElse
当m("e")的时候因为e这个key不存在所以会报错，使用m.getOrElse("e",0)当e不存在时返回默认值0
可变map
（1）构建
import scala.collection.mutable.Map
val m1 = Map("a" -> 111,"b" ->112 )
val修饰是不可变的，不可变的是对Map的引用，Map中打的元素是可以改变的
（2）修改map中的内容
m1("a")=88
(3)用+=号向原来的map中追加元素
m1+=("c" ->55)
15.元组
定义元祖时用小括号将多个元素包起来，元素之间用逗号分隔，元素类型可以不一样，元素类型可以任意多个
（1）定义元组
val y = ("a",3.14,111)
(2)获取元组中的值
val r = y._1
r="a"
获取元组中的值使用下划线加角标（_1）元组中的元素角标是从1开始的
（3）将对偶的集合转换成为映射
val arr = Array(("a",88),("b",66))
arr.toMap
Array(("a",88),("b",66))位对偶的集合
toMap可以把对偶的集合转换成为映射
（4）拉链操作
val names = Array("a","b","c")
val s = Array(1,2,3)
val ns = names.zip(s)
ns: Array[(String, Int)] = Array((a,1), (b,2), (c,3))
将names的每一个元素和s中的每一个元素组成元组放入到Array中
16.集合
(1)创建一个不可变的集合
val lst1 = List(1,2,3)
(2)将0插入到lst1的前面生成一个新的List
val lst2 = 0 :: lst1
:: 操作符是将给定的头和尾创建一个新的列表
注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
(3)将一个元素添加到lst1的后面产生一个新的集合
val lst6 = lst1 :+ 3
(4)将2个list合并成一个新的List
val lst7 = lst1 ++ lst6
(5)将lst0插入到lst1前面生成一个新的集合
val lst9 = lst1.:::(lst0)
可变的序列
(1)构建一个可变列表，初始有3个元素1,2,3
val lst0 = ListBuffer[Int](1,2,3)
(2)向lst1中追加元素，注意：没有生成新的集合
lst1 += 4
lst1.append(5)
(3)将lst1中的元素最近到lst0中， 注意：没有生成新的集合
lst0 ++= lst1
17.Set
不可变的Set
(1)定义set
import scala.collection.immutable.HashSet
val set1 = new HashSet[Int]()
（2）将元素和set1合并生成一个新的set，原有set不变
val set2 = set1 + 4
可变的Set
(1)创建一个可变的HashSet
import scala.collection.mutable
val set1 = new mutable.HashSet[Int]()
(2)向HashSet中添加元素
set1 += 2
//add等价于+=
set1.add(4)
set1 ++= Set(1,3,5)
(3)删除一个元素
set1 -= 5
set1.remove(2)
18.Map
(1)创建一个map
import scala.collection.mutable
val map1 = new mutable.HashMap[String, Int]()
(2)向map中添加数据
map1("spark") = 1
(3)从map中移除元素
map1.remove("spark")
19.单词统计
val lines = List("hello tom hello jerry", "hello jerry", "hello kitty")
实现1：
lines.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.foldLeft(0)(_+_._2))
分析：
（1）lines.flatMap(_.split(" ")) 将集合中的单词进行压平，其中每个元素通过" "来切分
lines.flatMap(_.split(" "))后为
res17: List[String] = List(hello, tom, hello, jerry, hello, jerry, hello, kitty)
（2）lines.flatMap(_.split(" ")).map((_, 1))统计每一个单词出现的次数，出现一次计数1
执行后为
res18: List[(String, Int)] = List((hello,1), (tom,1), (hello,1), (jerry,1), (hel
lo,1), (jerry,1), (hello,1), (kitty,1))
（3）.groupBy(_._1)将集合进行分组，分组是按照集合中每一个元组如（hello，1）的第一个单词（_._1）进行分组
分组后为一个map：
res19: scala.collection.immutable.Map[String,List[(String, Int)]] = Map(tom -> L
ist((tom,1)), kitty -> List((kitty,1)), jerry -> List((jerry,1), (jerry,1)), hel
lo -> List((hello,1), (hello,1), (hello,1), (hello,1)))
（4）.mapValues(_.foldLeft(0)(_+_._2)) 获取map中的所有values如 List((tom,1))，foldLeft进行统计，(0)初始化参数为0，_+_._2进行求和，第一个_在循环时可能为初始化参数和进行求和后的值
执行后为：
res20: scala.collection.immutable.Map[String,Int] = Map(tom -> 1, kitty -> 1, je
rry -> 2, hello -> 4)
实现2：
lines.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).map(t=>(t._1, t._2.size)).toList.sortBy(_._2).reverse
标签：产生 orm 推荐 多个 内容 添加元素 一点 包含 匿名
原文地址：http://www.cnblogs.com/csguo/p/7749997.html
