• partitionColumn：分区字段，需要是数值类的（partitionColumn must be a numeric column from the table in question.），经测试，除整型外，float、double、decimal都是可以的
• lowerBound：下界，必须为整数
• upperBound：上界，必须为整数
• numPartitions：最大分区数量，必须为整数，当为0或负整数时，实际的分区数为1；并不一定是最终的分区数量，例如“upperBound - lowerBound< numPartitions”时，实际的分区数量是“upperBound - lowerBound”；
• 在分区结果中，分区是连续的，虽然查看每条记录的分区，不是顺序的，但是将rdd保存为文件后，可以看出是顺序的。

在Mysql中创建表partition并插入数据，如下所示（两个字段都为int）：

在spark-shell中进行相关概念验证

1.    启动spark-shell
2.    在spark-shell中读取准备的mysql中的数据

scala> val jdbcDF = spark.read.format("jdbc").options(Map("url" ->  "jdbc:mysql://172.20.20.11:3306/testdepdb?user=testdep&password=testzet2018","dbtable" -> "testdepdb.partition","fetchSize" -> "20","partitionColumn" -> "seq", "lowerBound" -> "0", "upperBound" -> "10", "numPartitions" -> "5")).load()

3.    查看分区数

scala> jdbcDF.rdd.getNumPartitions
res6: Int = 5

4.    查看数据

scala> jdbc.show
+---+---------+
|seq|clicksNum|
+---+---------+
|  1|        1|
|  2|        2|
|  3|        3|
|  4|        4|
|  5|        5|
|  6|        6|
|  7|        7|
|  8|        8|
|  9|        9|
| 10|       10|
| 11|       11|
| 12|       12|
+---+---------+

5.    引入所需的库

import org.apache.spark.TaskContext

6.    打印每一行的partitionID

jdbcDF.foreach(row => {
      println("partitionId：" + TaskContext.get.partitionId)
partitionId：3
partitionId：3
partitionId：4
partitionId：4
partitionId：4
partitionId：4
partitionId：4
partitionId：2
partitionId：2
partitionId：0
partitionId：1
partitionId：1

7. 保存为文件

scala> jdbcDF.rdd.saveAsTextFile("file///tmp/test/partition")

8. 查看文件内容

[root@dmztdep21 partition]# ls
part-00000  part-00001  part-00002  part-00003  part-00004  _SUCCESS
[root@dmztdep21 partition]# cat part-00000
[1,1]
[root@dmztdep21 partition]# cat part-00001
[2,2]
[3,3]
[root@dmztdep21 partition]# cat part-00002
[4,4]
[5,5]
[root@dmztdep21 partition]# cat part-00003
[6,6]
[7,7]
[root@dmztdep21 partition]# cat part-00004
[8,8]
[9,9]
[10,10]
[11,11]
[12,12]

相关博客：

https://blog.csdn.net/wind520/article/details/52327942

https://stackoverflow.com/questions/41085238/whats-meaning-of-partitioncolumn-lowerbound-upperbound-numpartitions-paramete

关键概念partitionColumn：分区字段，需要是数值类的（partitionColumn must be a numeric column from the table in question.），经测试，除整型外，float、double、decimal都是可以的 lowerBound：下界，必须为整数 upperBound：上界，必须为整数 numPartitions：最大分... 这个插件包含一个生成随机数并将其存储在指定字段中的小部件。 Widget 将接受以下输入 |$lower |生成的随机数的下限，默认为 1。 |$upper |生成的随机数的上限，默认为 6。 |$step |生成的随机数的步长（即所有随机数将 采用 rand = lowerBound +n*stepSize 的形式，其中 n 是一个整数且 lowerBound <= rand <= upperBound ） stepSize 默认为 1（所以整数输出）。 如果 stepSize > upperBound - lowerBound 比输出总是 lowerBound | |$numrolls |滚动随机数并对结果求和的次数，如果没有给出值，则默认为 1。 | |$tiddler |将包含随机值的 tiddler，默认为<<curren * 非递归的二分查找：二分查找也可以用非递归的算法，但是分治算法通常要回到递归。分治算 * 法常常是一个方法，在这个方法中含有两个对自身的递归的调用。 * 分治算法：递归的二分查找是分治算法的一种实现方法。把一个是问题分成两个更小的问题， * 并且解决它们。这个过程一直持续下去直到易于求解的基值情况，就不需再分了。 * 分治算法常常是一上方法，在这个方法中含有两个对自身的递归调用，分别对应于 * 问题的两个部分。在二分查找中，就有两个这样的调用，但是只有一个真的执行了 * （调用哪一个取决于关键字的值）。 * 递归的效率：调用一个方法会有一定的代价和开销。首先，控制必须须从当前位置转移到调用 * 方法的开始处。其次，传给这个方法的参数以及这个方法返回地址都要初压到一 * 个栈里，为的是方法能够访问参数以及知道返回值在存储在哪里，这个过程也称 * "保存现场"。递归方法的使用的本质是从概念上简化了问题，而不是因为它更有 * 效率。当使用递归的效率很低的 时 候，就可以考虑如果把递归转化成非递归。 class OrdArray { private long[] a; private int nElems; public OrdArray(int max) { a = new long[max]; nElems = 0; public int size() { return nElems; public int find(long searchKey) { return recFind(searchKey, 0, nElems - 1);//调用递归方法 //return recFind2(searchKey, 0, nElems - 1);//调用非递归方法 public int recFind(long searchKey, int lowerBound , int upperBound ) {//递归方法定义 int curIn = ( lowerBound + upperBound ) / 2; if (a[curIn] == searchKey) { return curIn; } else if ( lowerBound > upperBound ) { return nElems; } else { if (a[curIn] < searchKey) { return recFind(searchKey, curIn + 1, upperBound ); } else { return recFind(searchKey, lowerBound , curIn - 1); public int recFind2(long searchKey, int lowerBound , int upperBound ){//非递归方法定义 int curIn=0; while(true){ curIn=( lowerBound + upperBound )/2; if(a[curIn]==searchKey) return curIn; else if( lowerBound > upperBound ) return nElems; else{ if(a[curIn]<searchKey){ lowerBound =curIn+1; else{ upperBound =curIn-1; public void insert(long value){ int j; for(j=0; j<nElems; j++) if(a[j]>value) break; for(int k=nElems; k>j; k--) a[k]=a[k-1]; a[j]=value; nElems++; public void display(){ for(int j=0; j<nElems; j++){ System.out.println(a[j]+""); class BinarySearchApp{ public static void main(String[] args){ int maxSize=100; OrdArray arr=new OrdArray(maxSize); arr.insert(72); arr.insert(90); arr.insert(45); arr.insert(126); arr.insert(54); arr.insert(99); arr.insert(144); arr.insert(27); arr.insert(135); arr.insert(81); arr.insert(18); arr.insert(100); arr.insert(9); arr.insert(117); arr.insert(63); arr.insert(36); arr.display(); int searchKey=100; if(arr.find(searchKey) !=arr.size()) System.out.println("Found "+searchKey); System.out.println("Can't find "+ searchKey); * 运行结果： * 100 * 117 * 126 * 135 * 144 * Found 100 * 总结： * 很多的数学问题都使用递归的方法解决，比如找两个数的最大公约数，求一个数的 * 乘方等等。如果有效率需求的 时 候，可以再考虑将递归转化成非递归。 更好的操纵杆允许用户与Arduino操纵杆组件进行交互。 它提供了对于操纵杆有意义的简单但有用的功能。 可以通过Arduino IDE中的库管理器安装Better Joystick。 可以使用构造函数中的相关引脚创建一个简单的Joystick对象，如下所示： Joystick joystick(A0, A1, 7); Joystick类包含许多可以以类似 方式 调用的方法。 int x（） 检索操纵杆的x位置 joystick.x() int y（） 检索操纵杆的y位置 joystick.y() int x（const int lowerBound ，const int upperBound ）; 从 lowerBound 映射到 lowerBound ， upperBound 之后，检索x位置。 int y（