scala小练习四

1.一千万个随机数，随机数范围在1到1亿之间，现在要求写出一种算法，将1到1亿之间没有出现的随机数求出来 第一题看这里

2 编 写 一 个 函 数 ， 接 收 一 个 字 符 串 集 合 ， 以 及 一 个 从 字 符 串 到 整 数 的 映 射 ，返回整数集合，其值为能和集合中某个字符串相应的映射值。举例来说，给Array(“Tom”,”Fred”,”Harry”) 和Map(“Tom”->3,”Dick”->4,”Harry”->5),返回Array(3,5)

做了两种实现，一种是map，一种是flatMap（注释部分）

//map将集合中的每个元素处理，并将处理后的结果返回,返回的是option // 而flatMap与map唯一不一样的地方就是传入的函数在处理完后返回值必须是List def func(a: Array[String], m: Map[String, Int]): Array[Int] = { //val res = a.flatMap(m.get(_))//简单的实现 var ans: Array[Int] = Array[Int]() val r = a.map(m.get(_)) for (a <- r) { ans = show(a, ans) } //从Option中取出Some中数据 def show(r: Option[Int], arr: Array[Int]) = r match { case None => arr case Some(s) => arr :+ s } ans }

3.对给定的整型列表lst,(lst :\ ListInt)(:: )得到的是什么? （ListInt /: lst）(:+)又得到什么?如何修改这两个操作，对原来列表反向操作？

val a=(lst :\ ListInt)(::) 等价于 val c=lst.foldRight(ListInt)(+:) 相当于foldRight，添加lst中的元素到ListInt,初始是一个空List 从右开始操作，每次添加的元素在左侧，所以只能用::或+:

val b=(ListInt/:lst)(:+) 等价于 val d=lst.foldLeft(ListInt)(:+) foldLeft,从左向右添加元素到列表，所以只能用:+

val lst =List[Int](1,2,3,4,5) val res1=(lst :\ List[Int]())((x,y)=>y:+x)//正向是x+:y，反过来即可 println("反向："+res1) val res2=(List[Int]() /: lst)((x,y)=>y+:x)//正向是x:+y，反过来即可 println("反向："+res2)

4.根据 flatMap 实现一个variance（方差）函数，如果一个序列的平均值m，variance是对序列中的每一个元素x进行math.pow（x-m,2） def variances(xs: Seq[Double]): Option[Double]

def variances(xs: Seq[Double]): Option[Double] = { val l=xs.length val m = xs.sum / l Some(xs.map(x=>math.pow(x-m,2)).sum/l) }

5.统计字符串中字母出现的频率映射，例如字符串 “scalajavajavascript”返回Map[Char,Int]。用aggregate 方法

val a="scalajavajavascript".par.aggregate(HashMap[Char,Int]())( (k,v)=>{//匿名函数,k打印得kMap(),是要返回的HashMap,v是单个字母 k+(v->(k.getOrElse(v,0)+1))//返回一个HashMap[Char,Int] } , //当不使用并行的时候，只有上部分就已经可以,这部分直接返回就可以 (k,v)=>(k.keySet++v.keySet).foldLeft((HashMap[Char,Int]())) {//k打印得kMap(),v打印得vMap()\ (res,keys)=>res+(keys->(k.getOrElse(keys,0)+v.getOrElse(keys,0))) } )

6.写出 ImageReader 的实现类

object work06 { trait Reader[T] { //read方法返回值是泛型，通过实现类的时候指定 def read(fileName: String): T } class StringReader extends Reader[String]{ def read(fileName: String) = Source.fromFile(fileName, "UTF-8").mkString } class ImageReader extends Reader[BufferedImage]{ override def read(fileName: String): BufferedImage = ImageIO.read(new File(fileName)) } } def main(args: Array[String]): Unit = { val a = new ImageReader println(a.read("image.png")) }

拿一张图片简单测试一下

真的读到了图片

7.定义一个不可变类Pair[T,S],带一个swap 方法，返回数组交换过位置的新对偶。

class Fair[T,S](a:(T,S)){ def swap:(S,T)={ (a._2,a._1) } } object work07 { def main(args: Array[String]): Unit = { val a=new Pair(1,'a') val b=a.swap println(b) } }

8 如果我们想把Pair[Person]的第一个组件替换为Student，为什么不需要给 replaceFirst 方法定义一个下界（代码不是答案，答案是文字）

object VarianceDemo { def makFriends(p: Pair[Person]): Unit = { } def main(args: Array[String]) { val p = new Pair[Student](new Student(), new Student()) //VarianceDemo.makFriends(p) } } class Pair[T](val first: T, val second: T) { def replaceFirst(newFirst: T) = new Pair[T](newFirst, second) } class Person {} class Student extends Person {}

答案： 因为Student是Person的子类型，可以直接去替换Person，根本不需要定义下界 那什么时候用下界呢？ 下界 R>: T 定义泛型R，R是T的超类 所以下界替换进来的类常常是原类型的超类型 如果我们需要用Person替换Student（超类替换子类），我们需要定义下界，代码如下

object VarianceDemo { def main(args: Array[String]) { val p = new Pair[Student](new Student(), new Student()) val a=new Person p.replaceFirst(a) } } class Pair[T](val first: T, val second: T) { def replaceFirst[R>:T](newFirst: R) = new Pair[R](newFirst, second) } class Person {} class Student extends Person {}

如果不定义下界，也可以通过编译，要求返回的 new Pair后面不指定[T]，此时返回的类型是Any 由此，可以理解‘界’这个概念

class Pair[T](val first: T, val second: T) { def replaceFirst[T](newFirst: T) = new Pair(newFirst, second) }

当然有种特别的情况 上述代码，R会被什么具体类型替换，取决于T和 newFirst 的类型。如果 newFirst 的类型刚好是T的基类，，R就直接是 newFirst 的类型。如果 newFirst 的类型不是T的基类，那R就会是T和 newFirst 的类型的共同基类

这道题真是给我整蒙了，甚至让我怀疑人生，因为刚刚看完协变，第一眼就把下界看成协变了，虽然后来看到是人家问的是下界，但协变就一直没从我脑中驱除，思维一直在协变和下界中穿梭，绞尽脑汁想着哪用上协变了啊，其实人家根本没问好嘛，这个过程虽煎熬，但也确实让我把这型变和界理解得更透彻

9 查看 Iterable [+A] 特质。哪些方法使用了类型参数A?为什么在这些方法中类型参数是协变的

foldLeft, foldRight等方法，因为Iterable特质声明类型A为协变

10 定义一个操作符+%，将一个给定的百分比添加到某个值。举例来说120 +% 10 = 132，由于操作符是方法而不是函数，你需要提供一个implicit

object work10 { //隐式转换的声明必须在要使用的位置之前，否则无效 //因为Double类型中并没有+%这个方法，所以这里把Double类型转换为A类型 implicit def doubleToA(x:Double)=new A(x) def main(args: Array[String]): Unit = { val res=120 +% 10 println(res) } } class A(x:Double){ def +%(y:Double)=x*y*0.01+x }