学习scala的那五天__第二天
本帖最后由 ABCDer丶Bi 于 2017-10-20 20:42 编辑学习scala的那五天__第一天
http://www.aboutyun.com/forum.php?mod=viewthread&tid=22957
(出处: about云开发)
第一天的作业答案会在后面楼层发布
2数组、映射、元组、集合 2.1数组
2.1.1定长数组和变长数组
//初始化一个长度为8的定长数组，其所有元素均为0
val arr1 = new Array(8) //直接打印定长数组，内容为数组的hashcode值 println(arr1) //将数组转换成数组缓冲，就可以看到原数组中的内容了 //toBuffer会将数组转换长数组缓冲
println(arr1.toBuffer)
//注意：如果不new，相当于调用了数组的apply方法，直接为数组赋值
//初始化一个长度为1的定长数组
val arr2 = Array(10)
println(arr2.toBuffer)
//定义一个长度为3的定长数组
val arr3 = Array("hadoop", "storm", "spark")
//使用()来访问元素
println(arr3(2))
//////////////////////////////////////////////////
//变长数组（数组缓冲）
//如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
val ab = ArrayBuffer()
//向数组缓冲的尾部追加一个元素
//+=尾部追加元素
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) 2.1.2遍历数组 1.增强for循环 2.好用的until会生成脚标，0 until 10 包含0不包含10 //初始化一个数组 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)) 2.1.3数组转换 yield关键字将原始的数组进行转换会产生一个新的数组，原始的数组不变 //定义一个数组 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) 2.1.3数组常用算法 在Scala中，数组上的某些方法对数组进行相应的操作非常方便！
2.2映射
2.2.1构建映射
2.2.2获取和修改映射中的值
好用的getOrElse
注意：在Scala中，有两种Map，一个是immutable包下的Map，该Map中的内容不可变；另一个是mutable包下的Map，该Map中的内容可变 例子： 注意：通常我们在创建一个集合是会用val这个关键字修饰一个变量（相当于java中的final），那么就意味着该变量的引用不可变，该引用中的内 容是不是可变，取决于这个引用指向的集合的类型2.3元组 映射是K/V对偶的集合，对偶是元组的最简单形式，元组可以装着多个不同类型的值。 2.3.1创建元组 2.3.2获取元组中的值 2.3.3将对偶的集合转换成映射 2.3.4拉链操作 zip命令可以将多个值绑定在一起 注意：如果两个数组的元素个数不一致，拉链操作后生成的数组的长度为较小的那个数组的元素个数 篇幅原因放在下面了
本帖最后由 ABCDer丶Bi 于 2017-10-20 20:40 编辑
2.4集合 Scala的集合有三大类：序列Seq、集合Set、映射Map，所有的集合都扩展自Iterable特质 在Scala中集合有可变（mutable）和不可变（immutable）两种类型，immutable类型的集合初始化后就不能改变了（注意与val修饰的变量进行区 别） 2.4.1序列Seq
不可变的序列 import scala.collection.immutable._
在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。 9 :: List(5, 2):: 操作符是将给定的头和尾创建一个新的列表 注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil)) //创建一个不可变的集合 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._ //构建一个可变列表，初始有3个元素1,2,3 val lst0 = ListBuffer(1,2,3) //创建一个空的可变列表 val lst1 = new ListBuffer //向lst1中追加元素，注意：没有生成新的集合 lst1 += 4 lst1.append(5)
//将lst1中的元素追加到lst0中， 注意：没有生成新的集合 lst0 ++= lst1
//将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合 val lst2= lst0 ++ lst1
//将元素追加到lst0的后面生成一个新的集合 val lst3 = lst0 :+ 5 2.4.2集合Set
不可变的Set
val set1 = new HashSet()
//将元素和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 //创建一个可变的HashSet
val set1 = new mutable.HashSet() //向HashSet中添加元素set1 += 2//add等价于+=set1.add(4)set1 ++= Set(1,3,5)println(set1) //删除一个元素set1 -= 5set1.remove(2)println(set1) 2.4.3映射Map 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)好吧,今天也就到这里了,被自己的排版折服
补充内容 (2017-10-21 09:30):
由于之前不是很会用这些东西,没有来得及审查,排版问题以及文字中间出现的错误,希望大家看的时候推敲一下,深表歉意.
补充内容 (2017-10-21 15:09):
学习scala的那五天__第二天缺失版
http://www.aboutyun.com/forum.php?mod=viewthread&tid=22961
(出处: about云开发)
ABCDer丶Bi 发表于 2017-10-20 19:55
噗...还没整理好,一个回车就出去了
有编辑按钮
本帖最后由 ABCDer丶Bi 于 2017-10-20 20:37 编辑
pig2 发表于 2017-10-20 20:16
有编辑按钮
看到咯,正在搞,谢谢了
本帖最后由 ABCDer丶Bi 于 2017-10-21 09:24 编辑
//第一天的练习答案
//创建一个List
val list0 = List(3,4,6,2,1,7,8,9,5)
//将list0中每个元素乘以2后生成一个新的集合
// val f1 = (x: Int) => x * 2
// val res = list0.map(f1)
// val res = list0.map(_ * 2)
//将list0的偶数取出来生成一个新的集合
// val res = list0.filter(_ % 2 == 0)
//将list0排序后生成一个新的集合
// val res = list0.sorted
//反转排序顺序
// val res = list0.sorted.reverse
//将list0中的元素4个一组,类型为Iterator]
val grouped: Iterator] = list0.grouped(4)
//将Iterator转换成List
// val res = grouped.toList
//将多个list压扁成一个List
val list2 = List(List(1,2,3), List(4,5,6), List(7,8,9))
// val res = list2.flatten
//先按空格切分，再压平
val list3 = List("hello java", "hello scala hello", "hello php", "hello python")
// val res = list3.map(_.split(" ")).flatten
val res = list3.flatMap(_.split(" "))
println(res)
val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
// 求和
// val res = arr.sum
//并行计算求和
// (1+2+3+4)+(5+6+7)+(8+9+10)
// val res = arr.par.sum
// reduce进行聚合
// val res = arr.reduce((x, y) => x + y)
// val res = arr.reduce(_ + _)
// val res = arr.reduceLeft(_ + _) // ((1+2)+3)+4 ...
// reduce进行聚合（按照非特定顺序）,并行聚合
// val res = arr.par.reduce(_+_)
// 例外
// val res = arr.par.reduceLeft(_+_) // ((1+2)+3)+4 ...
// val res = arr.par.reduceRight(_+_) // ((10+9)+8)+7 ...
// 并行求差
// val res = arr.reduce(_-_)
// val res = arr.par.reduce(_-_)
//折叠：有初始值（有特定顺序）
// val res = arr.fold(0)(_+_)
// val res = arr.fold(10)(_+_)
//折叠：有初始值（无特定顺序）
// val res = arr.par.fold(0)(_+_)
// 例如三个线程执行任务：(10+1+2+3+4)+(10+5+6+7)+(10+8+9+10)
// val res = arr.par.fold(10)(_+_)
// val res = arr.par.fold(10)(_-_)
//聚合
val list1 = List(List(1, 2, 3), List(3, 4, 5), List(2), List(0))
// val res = list1.flatten.reduce(_+_)
// val res = list1.flatten.fold(0)(_ + _)
// val res = list1.aggregate(0)(_+_.sum, _+_) // 内部其实还是调用的foldLeft（有特定顺序聚合）
// val res = list1.par.aggregate(10)(_+_.sum, _+_)
// 聚合,需求：结果为有个元组，元组里的第一个值是arr1的总和，第二个值是有多少个数参与聚合运算,(数组聚合的值，数组的长度)
val arr1 = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
// val res = arr1.aggregate((0, 0))(
// (acc, num) => (acc._1 + num, acc._2 + 1),
// (par1, par2) => (par1._1 + par2._1, par1._2 + par2._2)
// )
val l1 = List(5, 6, 4, 7)
val l2 = List(1, 2, 3, 4)
//求并集
// val res = l1 union l2
//求交集
// val res = l1 intersect l2
//求差集
// val res = l1.diff(l2)
// val res = l2.diff(l1)
// println(res)
{:2_31:}{:2_31:}{:2_31:}{:2_31:}{:2_31:}{:2_31:}
页:
[1]