comúnmente usada chispa del operador:
los operadores mapa:
original de cada elemento de datos de función personalizada RDD f mapas en un nuevo elemento en el mapa por el usuario, cada bloque representa una partición manera RDD, el lado izquierdo de la partición después de una definida por el usuario función f se asigna a la derecha de la nueva partición RDD, sin embargo, sólo para esperar hasta después de que se active la acción real del operador, estos datos f función y otras funciones realizado en una etapa de funcionamiento
operador mapValues:
dE (clave, valor) para el mapa de datos de tipo de valor de la operación de tecla sin cajas representan procesamiento realizado en la figura RDD partición a => a + 2 para el representante (V1,1) datos de valor de clave, tales como el valor de datos de desprendimiento de 1 operación más 2
operador flatmap
la R original para obtener una pluralidad de conjuntos cada RDD partición en cada elemento se convierte en un nuevo elemento por una función f, y la generada combinados en un conjunto de elementos
operador mapPartition:
para cada partición, la función de partición se realiza por los elementos de toda la operación iterador de toda la partición
operador de unión: actual y tomar
necesidad de asegurar que el mismo tipo de datos RDD dos elementos, el número de RDD devuelto Y el mismo tipo de datos se combinan RDD tipo de elemento, re-operación no se lleva a cabo para salvar a todos los elementos
operador ** cruce: ** intersectó
Esta función devuelve la intersección de dos de RDD, y para re-
operador groupbykey:
la ejecución de la antes de que las necesidades del operador a ser generados por la función del elemento correspondiente Key, los datos se convierten al formato de clave-valor, entonces el operador usará los mismos elementos clave agrupadas puede especificar el último número de particiones generadas groupbykey (x), x determinar el número de particiones y la función de partición, determina el grado de paralelización
Combinebykey: aggregateByKey foldByKey reduceByKey otras funciones se implementan en base a la función correspondiente a los elementos (int, RDD transición orden int (int SEQ [int]) RDD tipo de elemento)
(V1,2)
(V1,1) - -----> (Vl, SEC (2,1))
Reducebykey:
dos valores en un valor, (int, v int) ==== > (int, INTC)
por funciones definidas por el usuario (a, B) :( a la función + B), los mismos datos clave (V1,1), (V1,2) ----> (v1,3)
aggregatebykey:
en unidades de operación particiones, aggregatebykey (valor inicial, 1 función, la función 2)
Ejemplo: función lógica 1 definido de seleccionar el valor máximo es el valor de cada uno de la pluralidad de clave,
lógica funcional 2 se define mediante la suma de
la implementación subyacente:
1. la misma clave para cada partición, uno y comparar el valor inicial V1, V2 y el valor de retorno, el valor de retorno se adquiere ... hasta el máximo.
estadísticas de diferentes particiones 2. los agregados, las estadísticas globales obtenidos misma clave manera añadiendo
Sortbykey:
ordenados valores clave
operadores de combinación:
dos conexiones necesitan ser Cogroup función de operación RDD, los mismos primeros datos clave pueden ser colocados en la misma partición, la operación de forma después de Cogroup En nuevos RDD operar el producto cartesiano de los elementos en cada tecla, y los resultados a continuación devueltos aplanado, que corresponde a toda la forma ancestral un conjunto, devuelve RDD [(K, (V, W))] bajo clave
Operadores Cogroup substitución:
función Cogroup RDD dos divisiones en colaboración, par clave-valor en los dos tipos de elementos en el RDD, cada uno de los elementos clave RDD son la misma polimerización como un conjunto, y devuelve un iterador RDD dos elementos clave del conjunto correspondiente de es: (K, (Iterable [V ], Iterable [W])) donde, el valor del iterador es ancestral dos RDD dos datos clave idénticas compuestas por un conjunto de
operador cartesiano:
todo dentro de dos de la RDD cartesiano producto operación elemento
operador reparto:
RDD reparto de entrada
partición de salida para dividir el subconjunto de la entrada de
operador de filtro:
a elementos de filtro, el tipo del valor de retorno boolen, la verdadera retenido en RDD, la designación falsa se filtra
la muestra (falsa , 0.001,20):
Falso: si se debe volver
0,001: probabilidad
20: semilla de número aleatorio
para cada partición de RDD datos de muestreo de acuerdo con la tasa de muestreo, y devuelve un nuevo RDD
Takesample (operador Acción):
datos de impresión directa colección
el desarrollo de Java:
package com.spark;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import org.apache.cassandra.cli.CliParser.newColumnFamily_return;
import org.apache.hadoop.hive.ql.parse.HiveParser_IdentifiersParser.intervalLiteral_return;
import org.apache.hadoop.hive.ql.parse.HiveParser_IdentifiersParser.nullCondition_return;
import org.apache.hadoop.ipc.RetriableException;
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.FlatMapFunction;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import org.netlib.blas.Srot;
public class RDDOperation {
static String basedir = System.getProperty("user.dir"+File.separator+"conf"+File.separator);
public static void main(String[] args) {
SparkConf conf =new SparkConf().setAppName("RDDOperation").setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
mapDemo(sc);
System.out.println("-------------");
flatMapDemo(sc);
System.out.println("-------------");
filterDemo(sc);
System.out.println("-------------");
sampleDemo(sc);
System.out.println("-------------");
mapPartitionDemo(sc);
System.out.println("-------------");
groupByKeyDemo(sc);
System.out.println("-------------");
reduceByKeyDemo(sc);
System.out.println("-------------");
}
private static void mapDemo(JavaSparkContext sc) {
List<String> list =Arrays.asList("hadoop hbase hdfs spark storm","java scala python");
JavaRDD<String> stringRdd =sc.parallelize(list);//只有一个分区
// [hadoop hbase hdfs spark storm, java scala python]
// System.out.println(stringRdd.collect());
// map函数把rdd中的每一个元素传进来 一个元素“hadoop hbase hdfs spark stormpoiup”
JavaRDD<String[]>splitRdd =stringRdd.map(
new Function<String,String[]>(){
public static final long serialVersionUID=1L;
// call方法会被反复调用
public String[] call(String v1) {
return v1.split(" ");
}
});
List<String[]> result =splitRdd.collect();
for (int i = 0; i <result.size(); i++) {
for(String s :result.get(i)) {
System.out.println("Array"+i+"Data:"+ s);
}
}
}
private static void flatMapDemo(JavaSparkContext sc) {
List<List<String>> list =Arrays.asList(
Arrays.asList("hadoop hbase hdfs spark storm","java scala python"),
Arrays.asList("java scala python","beijing","zhejiang","shanghai"));
JavaRDD<List<String>> stringRdd =sc.parallelize(list);
JavaRDD<String>flatmapRdd=stringRdd.flatMap(
new FlatMapFunction<List<String>, String>() {
private static final long serialVersionUID=1L;
List<String> list =new ArrayList<String>();
String[] wordArr = null;
StringBuilder sb = new StringBuilder();
@Override
public Iterable<String> call(List<String> s) {
for (int i =0;i<s.size();i++) {
sb.append(s.get(i));
sb.append(" ");
}
wordArr = sb.toString().split(" ");
for (String word : wordArr) {
list.add(word);
}
return list;
}
});
System.out.println("source data "+ stringRdd.collect());
System.out.println("flatmapoutput"+ flatmapRdd.collect());
}
private static void filterDemo(JavaSparkContext sc) {
List<String> list = Arrays.asList("hadoop hbase hdfs spark strom","java scala r");
JavaRDD<String> stringRdd = sc.parallelize(list);
JavaRDD<String> filterRDD = stringRdd.filter(
new Function<String, Boolean>()
{
private static final long servialVersionUID=1L;
public Boolean call(String s) {
// s 包含两个元素
return s.contains("j");
// 返回“java scala r”
}
});
System.out.println(filterRDD.collect());
}
private static void mapPartitionDemo(JavaSparkContext sc) {
List<Integer> list = Arrays.asList(1,2,3,4,5,6);
JavaRDD<Integer> intRdd = sc.parallelize(list,2);
// 传进来的是一个一个分区
JavaRDD<Integer> mapPartitionRdd = intRdd.mapPartitions(
new FlatMapFunction<Iterator<Integer>, Integer>() {
private static final long servialVersionUID=1L;
public Iterable<Integer> call(Iterator<Integer> integerIterator) throws Exception {
List<Integer> list =new ArrayList<>();
while (integerIterator.hasNext()) {
list.add(integerIterator.next());
}
list.add(0);
return list;
}
});
System.out.println(mapPartitionRdd.collect());
}
private static void sampleDemo(JavaSparkContext sc) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10000; i++) {
list.add(i);
}
JavaRDD<Integer> intRdd= sc.parallelize(list);
// 是否放回采样 采样的概率 随机种子
JavaRDD<Integer> sampleRdd = intRdd.sample(false, 0.001,20);
System.out.println(sampleRdd.partitions().size());
System.out.print(sampleRdd.collect());
}
private static void groupByKeyDemo(JavaSparkContext sc) {
List<String> list =Arrays.asList("dog","tiger","lion","cat","spider","elephent");
JavaPairRDD<Integer, String> pairRDD = sc.parallelize(list).keyBy(new Function<String, Integer>() {
private static final long serialVersionUID=1L;
public Integer call(String v1) {
return v1.length();
}
});
JavaPairRDD<Integer, Iterable<String>> groupByPairRDD = pairRDD.groupByKey();
System.out.println(groupByPairRDD.collect());
}
private static void reduceByKeyDemo(JavaSparkContext sc) {
List<String> list = Arrays.asList("dog","cat","owl","gnu","ant");
JavaPairRDD<Integer, String> pairRDD = sc.parallelize(list).keyBy(new Function<String, Integer>() {
private static final long serialVersionUID=1L;
public Integer call(String v1) {
return v1.length();
// 返回 3，dog 3,cat....
}
});
//
JavaPairRDD<Integer, String> reduceByRdd = pairRDD.reduceByKey(
// 两个输入 一个输出
// 1.<k1,v1>中的v1 和 <k2,v2>中的v2 -----》 v1_v2
// v1-v2 v3----》v1-v2-v3
new Function2<String, String, String>() {
@Override
public String call(String v1, String v2) throws Exception {
// TODO Auto-generated method stub
return v1 + "-" + v2;
}
});
System.out.print(reduceByRdd.collect());
}
}
