Come ottenere ordina per valore nella scintilla java

Question

JavaPairRDD<String, Float> counts = ones 
      .reduceByKey(new Function2<Float, Float, Float>() { 
       @Override 
       public Float call(Float i1, Float i2) { 
        return i1 + i2; 
       } 
      }); 

La mia uscita è l è come:

id,value 
100002,23.47 
100003,42.78 
200003,50.45 
190001,30.23 

vorrei l'uscita da ordinare per valore come:

200003,50.45 
100003,42.78 
190001,30.23 
100002,23.47 

Come fare Posso raggiungerlo?

Answer 1

Penso che non ci siano API specifiche per ordinare i dati sul valore.

Può essere quello che dovete fare i passaggi qui sotto:

1) chiave Swap e il valore
2) Utilizzare sortByKey API
3) Tasto Swap e il valore

Guarda le maggiori dettagli su sortByKey in Beloe di riferimento:
https://spark.apache.org/docs/1.0.0/api/java/org/apache/spark/api/java/JavaPairRDD.html#sortByKey%28boolean%29

per lo swap, possiamo usare Scala Tuple API:

http://www.scala-lang.org/api/current/index.html#scala.Tuple2

Ad esempio, ho RDD Java Pair dalla funzione seguente.

JavaPairRDD<String, Integer> counts = ones.reduceByKey(new Function2<Integer, Integer, Integer>() { 
      @Override 
      public Integer call(Integer i1, Integer i2) { 
      return i1 + i2; 
      } 
    }); 

Ora, per scambiare chiave e valore, è possibile utilizzare il codice qui sotto:

JavaPairRDD<Integer, String> swappedPair = counts.mapToPair(new PairFunction<Tuple2<String, Integer>, Integer, String>() { 
      @Override 
      public Tuple2<Integer, String> call(Tuple2<String, Integer> item) throws Exception { 
       return item.swap(); 
      } 

     }); 

Spero che questo aiuti. È necessario prendersi cura dei tipi di dati.

Answer 2

Scala ha un bel metodo sortBy. Impossibile trovare l'equivalente Java, ma questa è l'implementazione Scala:

def sortBy[K](
     f: (T) => K, 
     ascending: Boolean = true, 
     numPartitions: Int = this.partitions.size) 
     (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T] = 
    this.keyBy[K](f) 
     .sortByKey(ascending, numPartitions) 
     .values 

Quindi, in sostanza simile al precedente, ma aggiunge una chiave invece di scambiare avanti e indietro. Lo uso in questo modo: .sortBy(_._2) (ordina selezionando il secondo elemento della tupla).