Java，Spark中二次排序（当前边的数相同的时候，将后边的封装成对象）【原理+Java代码】

一.原理： 

二次排序
        自己封装一个类，实现Comparable<SecondSortKey>接口，将要排序的字段当做属性放入类，类中实现compareTo方法，然后使用spark对Key 使用sortByKey排序。
        排序的字段大于2以上的都叫二次排序。

二次排序的思想：

是有两列数据，可能存在第一列数据相同时第二列数据不相同的情况，这时候就要考虑用二次排序的思想。

首先想到的是，将第二列的数据封装成对象，当第一列数据相同的时候，要按照第二列排序，这时候，我们就可以按照封装成的对象进行排序。对象可以单独封装成类。实现Serializable,Comparable两个接口。

排序顺序倒叙问题：第一列排序的时候，我们可以按照sortbykey中的true或者false来控制顺序，里边内层排序的时候，我们可以通过控制封装成的对象中的排序的正负号，来控制顺序。

排序的数字：

3 10
5 2
6 5
8 123
1 4
4 123
5 432
3 54
5 121
8 654
3 98

二.代码实现：

 上边的部分是将按照最前边的数字排序的：也就是按照第一列数据进行排序的

package com.bjsxt.spark.others.secondsort;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.api.java.function.VoidFunction;

import scala.Tuple2;

/**
 * 二次排序
 * 
 * @author root
 *
 */
public class SecondarySortTest {
	public static void main(String[] args) {
		SparkConf sparkConf = new SparkConf().setMaster("local").setAppName("SecondarySortTest");
		final JavaSparkContext sc = new JavaSparkContext(sparkConf);

		JavaRDD<String> secondRDD = sc.textFile("secondSort.txt");

		JavaPairRDD<SecondSortKey, String> pairSecondRDD = secondRDD
			.mapToPair(new PairFunction<String, SecondSortKey, String>() {

			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			public Tuple2<SecondSortKey, String> call(String line) throws Exception {
				String[] splited = line.split(" ");
				int first = Integer.valueOf(splited[0]);
				int second = Integer.valueOf(splited[1]);
				SecondSortKey secondSortKey = new SecondSortKey(first, second);
				return new Tuple2<SecondSortKey, String>(secondSortKey, line);
			}
			});

		pairSecondRDD.sortByKey(false).foreach(new VoidFunction<Tuple2<SecondSortKey, String>>() {
			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			public void call(Tuple2<SecondSortKey, String> tuple) throws Exception {
				System.out.println(tuple._2);
			}
		});
	}
}

————————————————————————————————————————————————————————

下边的是对于里边对象的排序，也就是按照第二列数据排序的：

package com.bjsxt.spark.others.secondsort;

import java.io.Serializable;

public class SecondSortKey implements Serializable, Comparable<SecondSortKey> {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private int first;
	private int second;

	public int getFirst() {
		return first;
	}

	public void setFirst(int first) {
		this.first = first;
	}

	public int getSecond() {
		return second;
	}

	public void setSecond(int second) {
		this.second = second;
	}

	public SecondSortKey(int first, int second) {
		super();
		this.first = first;
		this.second = second;
	}

	@Override
	public int compareTo(SecondSortKey o1) {
		if (getFirst() - o1.getFirst() == 0) {
			return getSecond() - o1.getSecond();
        //可以通过控制正负号来确定是按照升序排序还是按照降序排序
		} else {
			return getFirst() - o1.getFirst();
		}
	}
}

这下看起来就清洗明聊了。