java实现RDD算子

spark基础与java api介绍

http://www.cnblogs.com/tovin/p/3832405.html

 

 

textFile:                                                可将本地文件或HDFS文件转换成RDD，读取本地文件需要各节点上都存在，或者通过网络共享该文件

  JavaRDD<String> lines = sc.textFile(uri, 1);

 

 

 

 

union:             合并两个RDD

       

 JavaRDD<String> data1 = sc.textFile( "E:\\1.txt");
        JavaRDD<String> data2 = sc.textFile( "E:\\2.txt");
        JavaRDD<String> union = data1.union(data2);

 

 

 

saveAsTextFile:                                          将结果保存到HDFS中

  counts.saveAsTextFile (args[1]);

 

 

 

map：                 JavaRDD<T>  ->  JavaRDD<U>

  JavaRDD<Integer> lineLengths = lines.map( new Function<String, Integer>() {
  public Integer call(String s) { return s.length(); }
  });

JavaRDD<List<String>> transactions = data.map(
  new Function<String, List<String>>() {
  public List<String> call(String line) {
  String[] parts = line.split( " ");
  return Arrays. asList(parts);
  }
  }
  );
 
 
       
          JavaRDD<String>  ->  JavaRDD<List<String>> 
     JavaRDD<List<String>> transactions = data.map(
                   new Function<String, List<String>>() {
                         public List<String> call(String line) {
                              String[] parts = line.split( " ");
                               return Arrays. asList(parts);
                              }
                        }
                  );
 

 

 

 

        

 

 

 

reduce：               JavaRDD<T>  ->  T

  

int totalLength = lineLengths.reduce( new Function2<Integer, Integer, Integer>() {
  public Integer call(Integer a, Integer b) { return a + b; }
  });

 

 

 

flatmap：              JavaRDD<T> -> JavaRDD<U>             将一条 rdd数据使用你定义的函数给分解成多条 rdd数据

  

JavaRDD<String> words = lines.flatMap (new FlatMapFunction<String, String>() {
  public Iterable<String> call(String s) {
  return Arrays.asList(SPACE.split(s));
  }
  });
 
  JavaRDD<String> words = lines. flatMap( new FlatMapFunction<String, String>() {
  public Iterable<String> call(String s) {
  String[] words=s.split(" ");
  return Arrays.asList(words);
  }
  });

 

 

 

mapToPair:            JavaRDD<T> ->  JavaPairRDD<T, U>              pairFunction<T,K,V>: T:输入类型；K,V：输出键值对

 

 JavaPairRDD<String, Integer> ones = words.mapToPair( new PairFunction<String, String, Integer>() {
  //scala.Tuple2<K,V> call(T t)
  //Tuple2为 scala中的一个对象,call方法的输入参数为T,即输入一个单词s,新的Tuple2对象的key为这个单词,计数为1
  public Tuple2<String, Integer> call(String s) {
  return new Tuple2<String, Integer>(s, 1);
  }
  });

 

 

 

reduceByKey:           JavaPairRDD<T, U>  ->  JavaPairRDD<T, U> 

                                                                  调用Function2对象,Function2<T1,T2,R>,输入两个参数,T1,T2,返回R,若ones有<"one", 1>, 

                                                         <"one", 1>,会根据"one"将相同的pair单词个数进行统计,输入为Integer,输出也为Integer,输出<"one", 2>

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

 

 

 

collect:               JavaRDD<A, B, C...>  ->   List<TupleN<A, B, C...>>               返回一个包含RDD内所有元素的Array

 

 List<Tuple2<String, Integer>> output = counts. collect();
  for (Tuple2<?, ?> tuple : output) 
      System. out .println(tuple._1() + ": " + tuple._2());
  
 
  List<String> line = lines.collect();
  for (String val:line)
      System. out .println(val);
 
 
  
 for(Tuple2<String, Iterable<String>> tuple :instruction_sets.collect()){
            System. out.println(tuple._1());
            Iterator<String> it= tuple._2().iterator();
                   while(it.hasNext()){
                        System. out.println(it.next());
                  }
            System. out.println();
          }

 

filter:                JavaRDD<T>  ->  JavaRDD<U>                  定义一个返回 bool类型的函数，spark运行filter的时候会过滤掉那些返回只为false的数据    

 

 JavaRDD<String> contaninsE = lines.filter( new Function<String, Boolean>() {
  public Boolean call(String s) throws Exception {
  return (s.contains("they" ));
  }
  });

 

 

sortByKey:          JavaPairRDD<T, U>  ->  JavaPairRDD<T, U>       把RDD记录按key值的字典序从小到大排序

 

 JavaPairRDD<String,Integer> sort = counts.sortByKey();

 

 

groupByKey：         JavaPairRDD<U, T>  ->  JavaPairRDD<U, Iterable<T>>

                   groupByKey()会使用RDD中的键来对数据进行分组。对于一个由类型K的键和类型V的值组成的 

                   RDD，锁的到的结果RDD类型会是[K,Iterable[v]]。以下是程序示例，对PairRDD调用

                   groupByKey()函数之后，会返回JavaPairRDD<Integer,Iterable<Integer>>类型的结果，也就

                   是所有同一个Key的value都可以调用Iterator进行遍历。

 

 JavaPairRDD<String, Iterable<String>> instruction_sets = user_instruction.groupByKey();      
        //用户-指令集 -> 指令集  并去掉重复元素
        JavaRDD<List<String>> transactions = instruction_sets.map( new Function<Tuple2<String, Iterable<String>>, List<String>>() {
                   @Override
                   public List<String> call(Tuple2<String, Iterable<String>> sets)
                               throws Exception {
                         //将Iterable 转为List
                        List<String> list = new ArrayList<String>();
                   for(String s: sets. _2)
                        list.add(s);      
                   //删除重复元素
                  HashSet<String> set = new HashSet<String>(list);
                  ArrayList<String> listWithoutDuplicateElements = new ArrayList<String>(set);
                   return listWithoutDuplicateElements; 
                  }});

 

    小例子

List<Tuple2<Integer,Integer>> list1=new ArrayList<Tuple2<Integer, Integer>>();
    list1.add(new Tuple2<Integer,Integer>(1,1));
    list1.add(new Tuple2<Integer, Integer>(2,2));
    list1.add(new Tuple2<Integer, Integer>(1,3));
    list1.add(new Tuple2<Integer, Integer>(2,4));
    JavaPairRDD<Integer,Integer> nums1=sc.parallelizePairs(list1);
 
    JavaPairRDD<Integer,Iterable<Integer>>results =nums1.groupByKey();
 
    //接下来遍历输出results，注意其中关于Iterable遍历的处理
    for(Tuple2<Integer,Iterable<Integer>> tuple :results.collect()){
      System.out.print(tuple._1()+": ");
      Iterator<Integer> it= tuple._2().iterator();
      while(it.hasNext()){
      System.out.print(it.next()+" ");
      }
      System.out.println();
    }