使用java 实现二次排序

二次排序工具类:

import java.io.Serializable;
import scala.math.Ordered;

/**
* @author 作者 E-mail:
* @version 创建时间:2017年8月30日 下午3:48:11
* 类说明
*/
//二次排序key
public class SecondeIndexSort implements Ordered<SecondeIndexSort>, Serializable{

	private static final long serialVersionUID = -2366006422945129991L;

	// 首先在自定义key里面,定义需要进行排序的列
	private int first;
	private int second;

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

	@Override
	public boolean $greater(SecondeIndexSort other) {
		if(this.first > other.getFirst()) {
			return true;
		} else if(this.first == other.getFirst() &&
				this.second > other.getSecond()) {
			return true;
		}
		return false;
	}

	@Override
	public boolean $greater$eq(SecondeIndexSort other) {
		if(this.$greater(other)) {
			return true;
		} else if(this.first == other.getFirst() &&
				this.second == other.getSecond()) {
			return true;
		}
		return false;
	}

	@Override
	public boolean $less(SecondeIndexSort other) {
		if(this.first < other.getFirst()) {
			return true;
		} else if(this.first == other.getFirst() &&
				this.second < other.getSecond()) {
			return true;
		}
		return false;
	}

	@Override
	public boolean $less$eq(SecondeIndexSort other) {
		if(this.$less(other)) {
			return true;
		} else if(this.first == other.getFirst() &&
				this.second == other.getSecond()) {
			return true;
		}
		return false;
	}

	@Override
	public int compare(SecondeIndexSort other) {
		if(this.first - other.getFirst() != 0) {
			return this.first - other.getFirst();
		} else {
			return this.second - other.getSecond();
		}
	}

	@Override
	public int compareTo(SecondeIndexSort other) {
		if(this.first - other.getFirst() != 0) {
			return this.first - other.getFirst();
		} else {
			return this.second - other.getSecond();
		}
	}

	// 为要进行排序的多个列,提供getter和setter方法,以及hashcode和equals方法
	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;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + first;
		result = prime * result + second;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		SecondeIndexSort other = (SecondeIndexSort) obj;
		if (first != other.first)
			return false;
		if (second != other.second)
			return false;
		return true;
	}

}
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.Function;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.api.java.function.VoidFunction;

import scala.Tuple2;

/**
* @author 作者 E-mail:
* @version 创建时间:2017年8月30日 下午4:26:10
* 类说明
*/
public class SortIndexByKey {

	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setAppName("sortAction").setMaster("local");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<String> tf = sc.textFile("G://122.txt");
		JavaPairRDD<SecondeIndexSort, String> mapToPair = tf.mapToPair(new PairFunction<String, SecondeIndexSort, String>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Tuple2<SecondeIndexSort, String> call(String paramT) throws Exception {
				String[] lines = paramT.trim().split(" ");
				System.out.println("keys..."+Integer.valueOf(lines[0]));
				System.out.println("keys1..."+Integer.valueOf(lines[1]));
				SecondeIndexSort keys = new SecondeIndexSort(
						Integer.valueOf(lines[0]),
						Integer.valueOf(lines[1]));
				return new Tuple2<SecondeIndexSort, String>(keys, paramT);
			}
		});
		JavaPairRDD<SecondeIndexSort, String> sortByKey = mapToPair.sortByKey();
		JavaRDD<String> map = sortByKey.map(new Function<Tuple2<SecondeIndexSort,String>, String>() {

			private static final long serialVersionUID = 1L;

			@Override
			public String call(Tuple2<SecondeIndexSort, String> paramT1) throws Exception {

				return paramT1._2;
			}
		});
		map.foreach(new VoidFunction<String>() {

			private static final long serialVersionUID = 1L;

			@Override
			public void call(String paramT) throws Exception {
				System.out.println("..."+paramT);

			}
		});
		sc.close();

	}

}

  

 

 测试数据:

1 4
3 4
4 6
4 9
4 18
6 6
5 9
8 9
8 9
4 6

时间: 2024-10-03 13:38:43

使用java 实现二次排序的相关文章

Spark用Java实现二次排序的自定义key

本人在研究Spak,最近看了很多网上的对于SPARK用Java实现二次排序的方法,对于自定义key的做法 基本上都是实现Ordered<>接口,重写$greater.$greater$eq.$less.$less$eq.compare.compareTo方法,定义hashCode.equals····· 感觉好麻烦,其实我们自定义key只是用了里面的compareTo方法,其他的$greater.$greater$eq.$less.$less$eq.compare 不用做任何改动,hashCo

各种排序算法python和java实现(二)

第一篇博客实现了三种最基本最简单的排序算法,本篇文章将在这三种算法的基础上稍微演变一下. 1.快排 光从名字看就知道速度肯定不差,前一篇讲的冒泡排序,怎么看都不算是一种好的排序算法,里面充斥了太多的无谓的交换动作,时间复杂度倒是很稳定o(n^2),但对于排序算法实在说不过去.快排是冒泡排序的改进版,思路就是分治,将一个序列随机按照某个值分成两个子序列,子序列A里面的值全部比该值大,另一个子序列B的值全部比该值小,这听起来像是二叉排序树.然后依次对子序列进行如上操作,很明显快排最简单的实现就是用递

MapReduce排序之 二次排序

一:背景 Hadoop中虽然有自动排序和分组,由于自带的排序是按照Key进行排序的,有些时候,我们希望同时对Key和Value进行排序.自带的排序功能就无法满足我们了,还好Hadoop提供了一些组件可以让开发人员进行二次排序. 二:技术实现 我们先来看案例需求 #需求1: 首先按照第一列数字升序排列,当第一列数字相同时,第二列数字也升序排列(列之间用制表符\t隔开) [java] view plain copy 3   3 3   2 3   1 2   2 2   1 1   1 MapRed

Hadoop二次排序及MapReduce处理流程实例详解

一.概述 MapReduce框架对处理结果的输出会根据key值进行默认的排序,这个默认排序可以满足一部分需求,但是也是十分有限的,在我们实际的需求当中,往往有要对reduce输出结果进行二次排序的需求.对于二次排序的实现,网络上已经有很多人分享过了,但是对二次排序的实现原理及整个MapReduce框架的处理流程的分析还是有非常大的出入,而且部分分析是没有经过验证的.本文将通过一个实际的MapReduce二次排序的例子,讲述二次排序的实现和其MapReduce的整个处理流程,并且通过结果和Map.

MapReduce二次排序

本文主要介绍下二次排序的实现方式 我们知道MapReduce是按照key来进行排序的,那么如果有个需求就是先按照第一个字段排序,在第一个字段相等的情况下,按照第二个字段排序,这就是传说中的二次排序. 下面就具体说一下二次排序的实现方式 主要就是4点 1.自定义一个Key 为什么要自定义一个Key,我们知道MapReduce中排序就是按照Key来排序的,我们既然想要实现按照两个字段进行排序,默认的方式肯定是不行的,所以自定义一个新的Key,Key里面有两个属性,也就是我们要排序的两个字段. 首先,

大数据【四】MapReduce(单词计数;二次排序;计数器;join;分布式缓存)

   前言: 根据前面的几篇博客学习,现在可以进行MapReduce学习了.本篇博客首先阐述了MapReduce的概念及使用原理,其次直接从五个实验中实践学习(单词计数,二次排序,计数器,join,分布式缓存). 一 概述 定义 MapReduce是一种计算模型,简单的说就是将大批量的工作(数据)分解(MAP)执行,然后再将结果合并成最终结果(REDUCE).这样做的好处是可以在任务被分解后,可以通过大量机器进行并行计算,减少整个操作的时间. 适用范围:数据量大,但是数据种类小可以放入内存. 基

Java用vector容器排序

Java用vector容器排序 /** * 功能:定义一个Student数组,其中保存学生的基本信息,包括姓名,学号,性别,还有三门课的成绩 * 和课程对应的学分,计算出学分积,降序排序 * 时间:2014年6月4日16:33:24 * 作者:cutter_point */ package com.lesson4; import java.util.*; public class Demo4_10 { public static void main(String [] args) { //吧成绩

python 实现Hadoop的partitioner和二次排序

我们知道,一个典型的Map-Reduce过程包 括:Input->Map->Patition->Reduce->Output.Pation负责把Map任务输出的中间结果 按key分发给不同的Reduce任务进行处理.Hadoop 提供了一个非常实用的partitioner类KeyFieldBasedPartitioner,通过配置相应的参数就可以使用.通过 KeyFieldBasedPartitioner可以方便地实现二次排序. 使用方法:       -partitioner o

Hadoop.2.x_高级应用_二次排序及MapReduce端join

一.对于二次排序案例部分理解 1. 分析需求(首先对第一个字段排序,然后在对第二个字段排序) 杂乱的原始数据 排序完成的数据 a,1 a,1 b,1 a,2 a,2 [排序] a,100 b,6 ===> b,-3 c,2 b,-2 b,-2 b,1 a,100 b,6 b,-3 c,-7 c,-7 c,2 2. 分析[MapRedice过程] 1> 分析数据传入通过input()传入map() 2> map()对数据进行层层过滤,以达到我们想要的数据源, 3> 过滤方法中可添加自