scala BitSet实现算法：一千万个随机数，随机数范围在1到1亿之间，现在要求写出一种算法，将1到1亿之间没有出现的随机数求出来_mutiple exception thrown during a parallel computa-CSDN博客

闲话

跟BitSet缠了好几天，书上介绍的甚少，过了好几遍文档，和java的BitSet相比，可以像Set一样地操纵的设计更合理，但总觉得少了很多有用的方法，和其他Set相比，可能大数据量时效率提升明显，但使用者很难接触到底层的结构（java的BitSet并没有这样），很难作用最大化，曾无数次给我一种用了假BitSet的感觉，所以说的不对的，还请大家不吝赐教！

从实例出发

实现算法：一千万个随机数，随机数范围在1到1亿之间，现在要求写出一种算法，将1到1亿之间没有出现的随机数求出来

Version 1 最简单的实现

没有考虑大数据集的问题，效率可想而知

var bit:BitSet=BitSet()
var bat:BitSet=BitSet()
for(i<-1 to 100){
  bit+=i
}
for(i<-1 to 10 ){
  bat+=(new Random).nextInt(100)//随机数没要求是不重复的
}
val c:BitSet=bit--bat
println(c)
   
   1
2
3
4
5
6
7
8
9
10

Version 2 速度最快，但不准确

并行计算的效率让我欣喜若狂（超级快），但在这里出现了最多的问题，有些甚至至今仍未解决

var bit: BitSet = BitSet(100000000)
      var bat: BitSet = BitSet()
      (1 to 100000000).par.foreach(i => {
//        println(i)
        //问题一：这个地方导致了放弃这种方式，有并行，速度很快，但是不准确
        //神奇，并行得到的结果是不全的，丢失了部分数据，但在这做个打印，就不会丢失任何数据(测试了一下，挪动这个打印的位置到在后面都不行)
        //小数据集数据丢失明显，越大数据集越不明显，所以断定速度是真的提升，跟数据丢失关系不大
        bit += i
      })
      // 问题二：简直神奇！！当初始化bitset时为空时，最后这个括号和大括号在同一行就会报错,注释接在括号后面也会报错！！
      // Multiple exceptions thrown during a parallel computation 是ArrayIndexOutOfBoundsException
      // 初始化bit时加上100000000后不再报错，粗略测试了一下，加100000以上的数字都不再报错，小的数字不行，怀疑和初始化有关，但BitSet不是能自动扩容的吗，可能和超大数据量有关
      //下面这个循环有循环有同样的问题，所以我将结尾的括号和大括号放在不同行
      (1 to 100000000).par foreach (i => {
        bat += (new Random).nextInt(10) //随机数没要求是不重复的
      }
        )
      val res: BitSet = bit -- bat
      println("随机数中没有出现的数字集合：" + res)
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Version 3

其实是在写出最终版之后尝试做的改进，之后我一直在考虑速度，尝试使用Stream，延时计算，但并没起到加速的作用

val ss = BitSet()#:: {
  c ++ (1 to 100000000).par.toList
} #:: {
  b ++ (1 to 10000000).map(_ => Random.nextInt(99999999) + 1).toList
}#::Stream.empty[BitSet]
      val r = ss(1) -- ss(2)
   
   1
2
3
4
5
6

Version 4

更换了初始化的方式，但是更慢，可能是最终版的并行起到了作用

val s=BitSet((1 to 100000000):_*)
   
   1

Version 5 最终版

准确，速度一般，在idea中正常运行一分钟左右

object work01 {
  def main(args: Array[String]): Unit = {
    time {
      var b: BitSet = BitSet()
      var c: BitSet = BitSet()

      //用较小数据集测试
      //      val bat = c++(1 to 10).par.toList
      //      val bit = b ++ (1 to 5).map(_ => Random.nextInt(9) + 1).toList

      val bit = b ++ (1 to 1e8.toInt).map(_ => Random.nextInt(99999999) + 1).toList
      val bat = c ++ (1 to 1e8.toInt).par.toList //并没有要求随机数不重复

      //只计算未出现的数字的数量
      //      val r=1e8.toInt-bit.size
      //      println(r)

      //求出所有未出现的数字
      val r: BitSet = bat -- bit
      //      println(r)
      println(r.size)
    }
  }

  def time[R](block: => R): R = {
    val t0 = System.nanoTime()
    val result = block // call-by-name
    val t1 = System.nanoTime()
    println("Elapsed time: " + (t1 - t0) + "ns")
    result
  }
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32