Operator_join

package com.bjsxt.spark.transformations;

import java.util.Arrays;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.VoidFunction;

import scala.Tuple2;

import com.google.common.base.Optional;

public class Operator_join {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf();
        conf.setMaster("local").setAppName("join");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaPairRDD<Integer, String> nameRDD = sc.parallelizePairs(Arrays.asList(
                    new Tuple2<Integer, String>(0, "aa"),
                    new Tuple2<Integer, String>(1, "a"),
                    new Tuple2<Integer, String>(2, "b"),
                    new Tuple2<Integer, String>(3, "c")
                ));
        JavaPairRDD<Integer, Integer> scoreRDD = sc.parallelizePairs(Arrays.asList(
                new Tuple2<Integer, Integer>(1, 100),
                new Tuple2<Integer, Integer>(2, 200),
                new Tuple2<Integer, Integer>(3, 300),
                new Tuple2<Integer, Integer>(4, 400)
        ));
        JavaPairRDD<Integer, Tuple2<String, Integer>> join = nameRDD.join(scoreRDD);
//        System.out.println("join.partitions().size()--------"+join.partitions().size());
//        join.foreach(new VoidFunction<Tuple2<Integer,Tuple2<String,Integer>>>() {
//            
//            /**
//             * 
//             */
//            private static final long serialVersionUID = 1L;
//
//            @Override
//            public void call(Tuple2<Integer, Tuple2<String, Integer>> t)
//                    throws Exception {
//                System.out.println(t);
//            }
//        });
//            
//        JavaPairRDD<Integer, Tuple2<String, Optional<Integer>>> leftOuterJoin = nameRDD.leftOuterJoin(scoreRDD);
//        System.out.println("leftOuterJoin.partitions().size()--------"+leftOuterJoin.partitions().size());
//        leftOuterJoin.foreach(new VoidFunction<Tuple2<Integer,Tuple2<String,Optional<Integer>>>>() {
//
//            /**
//             * 
//             */
//            private static final long serialVersionUID = 1L;
//
//            @Override
//            public void call(
//                    Tuple2<Integer, Tuple2<String, Optional<Integer>>> t)
//                    throws Exception {
//                System.out.println(t);
//            }
//        });
        
//        JavaPairRDD<Integer, Tuple2<Optional<String>, Integer>> rightOuterJoin = nameRDD.rightOuterJoin(scoreRDD);
//        System.out.println("rightOuterJoin.partitions().size()--------"+rightOuterJoin.partitions().size());
//        rightOuterJoin.foreach(new VoidFunction<Tuple2<Integer,Tuple2<Optional<String>,Integer>>>() {
//            
//            /**
//             * 
//             */
//            private static final long serialVersionUID = 1L;
//
//            @Override
//            public void call(Tuple2<Integer, Tuple2<Optional<String>, Integer>> t)
//                    throws Exception {
//                System.out.println(t);
//            }
//        });
        
//        JavaPairRDD<Integer, Tuple2<Optional<String>, Optional<Integer>>> fullOuterJoin = nameRDD.fullOuterJoin(scoreRDD);
//        System.out.println("fullOuterJoin.partitions().size()--------"+fullOuterJoin.partitions().size());
//        
//        fullOuterJoin.foreach(new VoidFunction<Tuple2<Integer,Tuple2<Optional<String>,Optional<Integer>>>>() {
//
//            /**
//             * 
//             */
//            private static final long serialVersionUID = 1L;
//
//            @Override
//            public void call(
//                    Tuple2<Integer, Tuple2<Optional<String>, Optional<Integer>>> t)
//                    throws Exception {
//                System.out.println(t);
//            }
//        });
        
        
    }
}
 

转载于:https://my.oschina.net/u/3888695/blog/1831622

这是上题的代码:def infix_to_postfix(expression): precedence = {'!': 3, '&': 2, '|': 1, '(': 0} op_stack = [] postfix_list = [] token_list = expression.split() for token in token_list: if token.isalnum(): postfix_list.append(token) elif token == '(': op_stack.append(token) elif token == ')': top_token = op_stack.pop() while top_token != '(': postfix_list.append(top_token) top_token = op_stack.pop() else: # operator while op_stack and precedence[op_stack[-1]] >= precedence[token]: postfix_list.append(op_stack.pop()) op_stack.append(token) while op_stack: postfix_list.append(op_stack.pop()) return ' '.join(postfix_list) class Node: def __init__(self, value): self.value = value self.left_child = None self.right_child = None def build_expression_tree(postfix_expr): operator_stack = [] token_list = postfix_expr.split() for token in token_list: if token.isalnum(): node = Node(token) operator_stack.append(node) else: right_node = operator_stack.pop() left_node = operator_stack.pop() node = Node(token) node.left_child = left_node node.right_child = right_node operator_stack.append(node) return operator_stack.pop() def evaluate_expression_tree(node, variable_values): if node.value.isalnum(): return variable_values[node.value] else: left_value = evaluate_expression_tree(node.left_child, variable_values) right_value = evaluate_expression_tree(node.right_child, variable_values) if node.value == '!': return not left_value elif node.value == '&': return left_value and right_value elif node.value == '|': return left_value or right_value expression = "!a & (b | c)" postfix_expression = infix_to_postfix(expression) expression_tree = build_expression_tree(postfix_expression) variable_values = {'a': True, 'b': False, 'c': True} result = evaluate_expression_tree(expression_tree, variable_values) print(result)
06-12
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值