java实现RDD算子

原创 2017年01月03日 13:32:30
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();
    }

 

 
 
 
版权声明:欢迎交流讨论,转载请注明出处

相关文章推荐

RDD JAVA API 用法指南

1.RDD介绍:     RDD,弹性分布式数据集,即分布式的元素集合。在spark中,对所有数据的操作不外乎是创建RDD、转化已有的RDD以及调用RDD操作进行求值。在这一切的背后,Spark会自...

Spark PairRDD 转化二

package edu.berkeley.simple_project; import java.util.ArrayList; import java.util.Arrays; import ja...

Spark Programming by Java——RDD基本操作

Spark Programming on Java——RDD基本操作 在一个内容为{1, 2, 3, 3}的RDD上进行的基本操作 函数名(表现形式为scala) 目的 示例 结果 ...

Java接入Spark之创建RDD的两种方式和操作RDD

Java接入Spark之创建RDD的两种方式和操作RDD

离线轻量级大数据平台Spark之JavaRDD关联join操作

对两个RDD进行关联操作,如: 1)文件post_data.txt包含:post_id\title\content 2)文件train.txt包含:dev_id\post_id\praise\time...

Spark——RDD操作详解

一、基本RDD 1、针对各个元素的转化操作 最常用的转化操作是map()和filter()。转化操作map()J接收一个函数,把这个函数用于RDD中的每一个元素,将函数的返回结果作为结果RDD中对...

Spark排序算法!! 使用java开发 自定义key值 进行二次排序 深入解析!

Spark使用JAVA开发的二次排序 【数据文件Input】 2 3  4 1  3 2  4 3  8 7  2 1 【运行结果Output】 2 1  2 3  3 2  ...

Spark java程序入门(二)创建RDD与查看RDD内容

使用Spark需要RDD编程,而RDD编程的第一步就是构建RDD 有两种方法创建RDD (1)从文件系统中直接读入一个外部数据集, 一个简单的例子,比如  JavaRDD input =...

Spark JAVA RDD API 最全合集整理,持续更新中~

SPARK的核心就是RDD,对SPARK的使用入门也就是对RDD的使用, 对于JAVA的开发者,Spark的RDD对JAVA的API我表示很不能上手, 单单看文档根本是没有办法理解每个API的作用...
  • xiefu5hh
  • xiefu5hh
  • 2016年06月29日 10:35
  • 11601

【Spark Java API】Action(3)—foreach、foreachPartition、lookup

spark java api...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java实现RDD算子
举报原因:
原因补充:

(最多只允许输入30个字)