mapreduce小demo_自定义分组聚合规则

最新推荐文章于 2022-06-26 12:15:07 发布
最新推荐文章于 2022-06-26 12:15:07 发布
阅读量628 收藏 3
点赞数
分类专栏： hadoop 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30648823/article/details/87899140
版权

mapreduce小demo

1.单词分类

a.txt    
hello tom   
hello jim   
hello kitty     
hello rose  

b.txt   
hello jerry     
hello jim   
hello kitty     
hello jack  

c.txt       
hello jerry     
hello java      
hello c++       
hello c++       

需要得到以下结果：   
hello  a.txt-->4  b.txt-->4  c.txt-->4      
java   c.txt-->1        
jerry  b.txt-->1  c.txt-->1

…

1.1 思路

1 将单词个数以及文件位置 统计个数
2 将相同的单词 将数据合并为一条数据

1.2 代码

得到文件名
从输入切片信息中获取当前正在处理的一行数据所属的文件
InputSplit 的实现类 FileSplit inputSplit = （FileSplit）context.getInputSplit();

1. 第一步

  1. IndexesMapper
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

import java.io.IOException;

public class IndexesMapper extends Mapper<LongWritable, Text, Text , IntWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        FileSplit inputSplit = (FileSplit) context.getInputSplit();
        String fileName = inputSplit.getPath().getName();

        String[] str = value.toString().split(" ");

        for (String s : str) {
            context.write(new Text(s+"-"+fileName), new IntWritable(1));
        }
    }
}
  1. IndexesReduce
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class IndexesReduce extends Reducer<Text, IntWritable, Text, IntWritable> {
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int temp = 0;
        for (IntWritable value : values) {
            temp+=1;
        }
        context.write(key,new IntWritable(temp));
    }
}
  1. IndexesSub

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class IndexesSub {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        job.setJarByClass(IndexesSub.class);

        job.setMapperClass(IndexesMapper.class);
        job.setReducerClass(IndexesReduce.class);

        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        FileInputFormat.setInputPaths(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\索引数据"));
        FileOutputFormat.setOutputPath(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\output"));

        job.waitForCompletion(true);
    }
}

1. 第二步

1 IndexSecMapper

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class IndexSecMapper extends Mapper<LongWritable, Text, Text, Text> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] str = value.toString().split("-");
        context.write(new Text(str[0]), new Text(str[1]));
    }
}

2 IndexSecReduce

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class IndexSecReduce extends Reducer<Text, Text, Text, Text> {
    @Override
    protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        StringBuilder stringBuilder = new StringBuilder();
        for (Text value : values) {
            stringBuilder.append("  >"+value.toString());
        }
        context.write(key, new Text(stringBuilder.toString()));
    }
}

3 IndexSecSub

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class IndexSecSub {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        job.setJarByClass(IndexSecSub.class);

        job.setMapperClass(IndexSecMapper.class);
        job.setReducerClass(IndexSecReduce.class);

        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        FileInputFormat.setInputPaths(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\output"));
        FileOutputFormat.setOutputPath(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\output2"));

        job.waitForCompletion(true);
    }
}

2.需要求出每一个订单中成交金额最大的三笔

order001,u001,小米6,1999.9,2
order001,u001,雀巢咖啡,99.0,2
order001,u001,安慕希,250.0,2
order001,u001,经典红双喜,200.0,4
order001,u001,防水电脑包,400.0,2
order002,u002,小米手环,199.0,3
order002,u002,榴莲,15.0,10
order002,u002,苹果,4.5,20
order002,u002,肥皂,10.0,40
order003,u001,小米6,1999.9,2
order003,u001,雀巢咖啡,99.0,2
order003,u001,安慕希,250.0,2
order003,u001,经典红双喜,200.0,4
order003,u001,防水电脑包,400.0,2

2.1 代码

2.1.1 OrderMapper

public class OrderMapper extends Mapper<LongWritable, Text, Text, OrderBean> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] split = value.toString().split(",");

        context.write(new Text(split[0]),
                new OrderBean(split[0],split[1],split[2],Float.parseFloat(split[3]),Integer.parseInt(split[4])));
    }
}

2.1.2 OrderReduce

public class OrderReduce extends Reducer<Text, OrderBean, OrderBean, NullWritable> {
    @Override
    protected void reduce(Text key, Iterable<OrderBean> values, Context context) throws IOException, InterruptedException {
        List<OrderBean> orderBeans = new ArrayList<OrderBean>();

        for (OrderBean value : values) {
            orderBeans.add(new OrderBean(value));
        }

        Collections.sort(orderBeans);

        for (int i = 0; i < 3; i++) {
            context.write(orderBeans.get(i), NullWritable.get());
        }
    }
}

2.1.3 OrderSub

public class OrderSub {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        job.setJarByClass(OrderSub.class);
        job.setMapperClass(OrderMapper.class);
        job.setReducerClass(OrderReduce.class);

        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(OrderBean.class);

        job.setOutputKeyClass(OrderBean.class);
        job.setOutputValueClass(NullWritable.class);

        FileInputFormat.setInputPaths(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\交金额最大的三笔\\input"));
        FileOutputFormat.setOutputPath(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\交金额最大的三笔\\output"));

        job.waitForCompletion(true);

    }
}

2.1.4 OrderBean

public class OrderBean implements WritableComparable<OrderBean> {
    private String orderId;
    private String userId;
    private String comName;
    private Float price;
    private Integer nub;
    private Float subPrice;

    @Override
    public String toString() {
        return orderId+"\t"+userId+"\t"+comName+"\t"+price+"\t"+nub+subPrice;
    }


    public int compareTo(OrderBean o) {
        Float temp = o.getSubPrice() - this.getSubPrice();
        if (temp == 0){
            return this.getComName().compareTo(o.getComName());
        }else if (temp>0){
            return 1;
        }else{
            return 0;
        }
    }

    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeUTF(this.orderId);
        dataOutput.writeUTF(this.userId);
        dataOutput.writeUTF(this.comName);
        dataOutput.writeFloat(this.price);
        dataOutput.writeInt(this.nub);
        dataOutput.writeFloat(this.subPrice);
    }

    public void readFields(DataInput dataInput) throws IOException {
        this.orderId = dataInput.readUTF();
        this.userId = dataInput.readUTF();
        this.comName = dataInput.readUTF();
        this.price = dataInput.readFloat();
        this. nub = dataInput.readInt();
        this.subPrice = price*nub;
    }

    public OrderBean() {}

    public OrderBean(OrderBean ob){
        this.orderId = ob.getOrderId();
        this.userId = ob.getUserId();
        this.comName = ob.getComName();
        this.price = ob.getPrice();
        this.nub = ob.getNub();
        this.subPrice = ob.getSubPrice();
    }

    public OrderBean(String orderId, String userId, String comName, Float price, Integer nub) {
        this.orderId = orderId;
        this.userId = userId;
        this.comName = comName;
        this.price = price;
        this.nub = nub;
        this.subPrice = price*nub;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getComName() {
        return comName;
    }

    public void setComName(String comName) {
        this.comName = comName;
    }

    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        this.price = price;
    }

    public Integer getNub() {
        return nub;
    }

    public void setNub(Integer nub) {
        this.nub = nub;
    }

    public Float getSubPrice() {
        return subPrice;
    }

    public void setSubPrice(Float subPrice) {
        this.subPrice = subPrice;
    }
}

2.2 解释

  1. 排序
    1. bean 中调用 WritableComparable 接口
          public int compareTo(OrderBean o) {
            Float temp = o.getSubPrice() - this.getSubPrice();
            if (temp == 0){
                return this.getComName().compareTo(o.getComName());
            }else if (temp>0){
                return 1;
            }else{
                return 0;
            }
        }
    1. OrderReduce中使用
         List<OrderBean> orderBeans = new ArrayList<OrderBean>();
    
    for (OrderBean value : values) {
        orderBeans.add(new OrderBean(value));
    }

    Collections.sort(orderBeans);

2.2 输出

order001	u001	雀巢咖啡	99.0	2198.0
order001	u001	安慕希	250.0	2500.0
order001	u001	小米6	1999.9	23999.8
order002	u002	榴莲	15.0	10150.0
order002	u002	肥皂	10.0	40400.0
order002	u002	苹果	4.5	2090.0
order003	u001	小米6	1999.9	23999.8
order003	u001	雀巢咖啡	99.0	2198.0
order003	u001	安慕希	250.0	2500.0

2.3 优化

自定义分发规则

  1. 自定义 mapper分发的规则
public class OptimizeOrderPartitione extends Partitioner<OrderBean, NullWritable> {

    @Override
    public int getPartition(OrderBean orderBean, NullWritable nullWritable, int i) {
        return (orderBean.getOrderId().hashCode() & Integer.MAX_VALUE)%i;
    }
}
  1. 自定义 reduce对比的规则（分组比较器）
public class OptimizeOrderGroupingComparator extends WritableComparator {

    public OptimizeOrderGroupingComparator(){
        super(OrderBean.class,true);
    }

    @Override
    public int compare(WritableComparable a, WritableComparable b) {
        OrderBean o1 = (OrderBean) a;
        OrderBean o2 = (OrderBean) b;

        //返回为零则代表相同
        return o1.getOrderId().compareTo(o2.getOrderId());
    }
}
  1. bean 中的compareTo
public int compareTo(OrderBean o) {
   return this.getOrderId().compareTo(o.getOrderId())==0 ? Float.compare(o.getSubPrice(),this.getSubPrice()):this.getOrderId().compareTo(o.getOrderId());
}

代码

public class OptimizeOrder {
    public static class OpOrdMapper extends Mapper<LongWritable, Text, OrderBean, NullWritable> {
        NullWritable v = NullWritable.get();
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] split = value.toString().split(",");

            context.write(new OrderBean(
                    split[0],split[1],split[2],Float.parseFloat(split[3]),Integer.parseInt(split[4])),v);
        }
    }

    public static class OpOrdReduce extends Reducer<OrderBean, NullWritable, OrderBean, NullWritable>{
        @Override
        protected void reduce(OrderBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
            int temp = 0;
            for (NullWritable value : values) {
                context.write(key, value);
                if (++temp==3){
                    return;
                }
            }
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        job.setJarByClass(OptimizeOrder.class);

        job.setMapperClass(OpOrdMapper.class);
        job.setReducerClass(OpOrdReduce.class);

        job.setMapOutputKeyClass(OrderBean.class);
        job.setMapOutputValueClass(NullWritable.class);

        job.setOutputKeyClass(OrderBean.class);
        job.setOutputValueClass(NullWritable.class);

        //设置分割器
        job.setPartitionerClass(OptimizeOrderPartitione.class);
        //设置分组比较器
        job.setGroupingComparatorClass(OptimizeOrderGroupingComparator.class);



        FileInputFormat.setInputPaths(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\交金额最大的三笔\\input"));
        FileOutputFormat.setOutputPath(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\交金额最大的三笔\\output2"));

        job.waitForCompletion(true);
    }
}

3.共同好友分析

A:B,C,D,F,E,O
B:A,C,E,K
C:F,A,D,I
D:A,E,F,L
E:B,C,D,M,L
F:A,B,C,D,E,O,M
G:A,C,D,E,F
H:A,C,D,E,O
I:A,O
J:B,O
K:A,C,D
L:D,E,F
M:E,F,G
O:A,H,I,J

3.1 代码

  1. 第一步
public class MutualFriend {
    public static class MutualFriendMapper extends Mapper<LongWritable, Text, Text, Text>{
        Text k = new Text();
        Text v = new Text();
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] split = value.toString().split(":");
            String[] split1 = split[1].split(",");
            v.set(split[0]);
            for (String s : split1) {
                k.set(s);
                context.write(k,v);
            }
        }
    }


    public static class MutualFriendReduce extends Reducer<Text,Text,Text,Text>{
        Text k = new Text();
        Text v = new Text();
        @Override
        protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
            List<String> list = new ArrayList<String>();
            for (Text value : values) {
                list.add(value.toString());
            }

            v.set(key);
            for (int i =0 ;i<list.size()-1;i++){
                for (int j = i+1; j<list.size();j++){
                    k.set(list.get(i)+"-"+list.get(j));
                    context.write(k,v);
                }
            }

        }
    }
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);
        job.setJarByClass(MutualFriend.class);
        job.setMapperClass(MutualFriendMapper.class);
        job.setReducerClass(MutualFriendReduce.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        FileInputFormat.setInputPaths(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\共同好友\\input"));
        FileOutputFormat.setOutputPath(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\共同好友\\output"));

        job.waitForCompletion(true);
    }
}

结果：

I-K	A
I-C	A
I-B	A
I-G	A
I-F	A
I-H	A
I-O	A
I-D	A
K-C	A
K-B	A
K-G	A
K-F	A
K-H	A
K-O	A
K-D	A
C-B	A
C-G	A
C-F	A
C-H	A
C-O	A
C-D	A
B-G	A
B-F	A
B-H	A
B-O	A
B-D	A
G-F	A
G-H	A
G-O	A
G-D	A
F-H	A
F-O	A
F-D	A
H-O	A
H-D	A
O-D	A
A-F	B
A-J	B
A-E	B
F-J	B
F-E	B
J-E	B
A-E	C
A-B	C
A-H	C
A-F	C
A-G	C
A-K	C
E-B	C
E-H	C
E-F	C
E-G	C
E-K	C
B-H	C
B-F	C
B-G	C
B-K	C
H-F	C
H-G	C
H-K	C
F-G	C
F-K	C
G-K	C
G-C	D
G-K	D
G-A	D
G-L	D
G-F	D
G-E	D
G-H	D
C-K	D
C-A	D
C-L	D
C-F	D
C-E	D
C-H	D
K-A	D
K-L	D
K-F	D
K-E	D
K-H	D
A-L	D
A-F	D
A-E	D
A-H	D
L-F	D
L-E	D
L-H	D
F-E	D
F-H	D
E-H	D
G-M	E
G-L	E
G-H	E
G-A	E
G-F	E
G-B	E
G-D	E
M-L	E
M-H	E
M-A	E
M-F	E
M-B	E
M-D	E
L-H	E
L-A	E
L-F	E
L-B	E
L-D	E
H-A	E
H-F	E
H-B	E
H-D	E
A-F	E
A-B	E
A-D	E
F-B	E
F-D	E
B-D	E
L-M	F
L-D	F
L-C	F
L-G	F
L-A	F
M-D	F
M-C	F
M-G	F
M-A	F
D-C	F
D-G	F
D-A	F
C-G	F
C-A	F
G-A	F
O-C	I
D-E	L
E-F	M
A-H	O
A-I	O
A-J	O
A-F	O
H-I	O
H-J	O
H-F	O
I-J	O
I-F	O
J-F	O
  1. 第二步
public class MutualFriend2 {
    public static class MutualFriend2Mapper extends Mapper<LongWritable, Text, Text, Text>{
        Text k = new Text();
        Text v = new Text();
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] split = value.toString().split("\t");
            k.set(split[0]);
            v.set(split[1]);
            context.write(k,v);
        }
    }

    public static class MutualFriend2Reduce extends Reducer<Text,Text,Text,Text>{
        Text k = new Text();
        Text v = new Text();
        @Override
        protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
            k.set(key+">");
            StringBuilder stringBuilder = new StringBuilder();

            for (Text value : values) {
                stringBuilder.append(value.toString()+"\t");
            }
            v.set(stringBuilder.toString());

            context.write(k, v);
        }
    }
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);
        job.setJarByClass(MutualFriend2.class);
        job.setMapperClass(MutualFriend2Mapper.class);
        job.setReducerClass(MutualFriend2Reduce.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        FileInputFormat.setInputPaths(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\共同好友\\output"));
        FileOutputFormat.setOutputPath(job, new Path("E:\\soft\\java\\ideaProject\\hadoop\\file\\倒排索引demo\\共同好友\\output2"));

        job.waitForCompletion(true);
    }
}

结果：

A-B>	E	C	
A-D>	E	
A-E>	D	C	B	
A-F>	C	D	B	O	E	
A-G>	C	
A-H>	D	O	C	
A-I>	O	
A-J>	O	B	
A-K>	C	
A-L>	D	
B-D>	E	A	
B-F>	C	A	
B-G>	C	A	
B-H>	C	A	
B-K>	C	
B-O>	A	
C-A>	D	F	
C-B>	A	
C-D>	A	
C-E>	D	
C-F>	D	A	
C-G>	F	A	
C-H>	A	D	
C-K>	D	
C-L>	D	
C-O>	A	
D-A>	F	
D-C>	F	
D-E>	L	
D-G>	F	
E-B>	C	
E-F>	M	C	
E-G>	C	
E-H>	C	D	
E-K>	C	
F-B>	E	
F-D>	E	A	
F-E>	B	D	
F-G>	C	
F-H>	D	A	
F-J>	B	
F-K>	C	
F-O>	A	
G-A>	E	D	F	
G-B>	E	
G-C>	D	
G-D>	E	A	
G-E>	D	
G-F>	D	E	A	
G-H>	E	A	D	
G-K>	D	C	
G-L>	D	E	
G-M>	E	
G-O>	A	
H-A>	E	
H-B>	E	
H-D>	A	E	
H-F>	C	E	O	
H-G>	C	
H-I>	O	
H-J>	O	
H-K>	C	
H-O>	A	
I-B>	A	
I-C>	A	
I-D>	A	
I-F>	A	O	
I-G>	A	
I-H>	A	
I-J>	O	
I-K>	A	
I-O>	A	
J-E>	B	
J-F>	O	
K-A>	D	
K-B>	A	
K-C>	A	
K-D>	A	
K-E>	D	
K-F>	D	A	
K-G>	A	
K-H>	D	A	
K-L>	D	
K-O>	A	
L-A>	F	E	
L-B>	E	
L-C>	F	
L-D>	E	F	
L-E>	D	
L-F>	E	D	
L-G>	F	
L-H>	E	D	
L-M>	F	
M-A>	F	E	
M-B>	E	
M-C>	F	
M-D>	F	E	
M-F>	E	
M-G>	F	
M-H>	E	
M-L>	E	
O-C>	I	
O-D>	A
_shutter_
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MapReduce案例之分组
QYHuiiQ
06-13 921
在MapReduce中，分组主要是用于确定将哪些数据作为一个组，相同的key会被分为一组，然后调用一次reduce方法。默认情况下不同的key会被分为不同的组，从而每个组都会调用一次reduce方法。但是如果我们的业务中需要将不同的key放在同一个组里，调用一次reduce方法，那么就需要我们去自定义实现分组。在该案例中我们要实现的是将学生的语文、数学、英语成绩进行分组，并求出每个科目（每组）中成绩最高的一条数据。实现的大致思路：将数据上传至HDFS: 新建project： 自定义JavaBe
hadoop mapreduce 自定义分组实现
qq_41854797的博客
05-20 546
hadoop mapreduce 自定义分组实现 任务要求：对流量日志进行流量统计，将不同省份的用户统计结果输出到不同的文件； 需要自定义改造两个机制： 1、改造分区的逻辑，自定义一个Partitioner类 2、自定义reducer task的并发任务数； 具体代码java： mapreduce 以及 主类代码： package com.cjp.areaPartitioner; impor...
MapReduce（4）--MapReduce 统计求和，排序
kismet
11-18 3473
1.统计求和，需求： 统计每个手机号的上行流量总和，下行流量总和，上行总流量之和，下行总流量之和 文件： 13631579850 13726230503 00-FD-07-A4-72-B8:CMCC 120.196.100.82 i02.c.aliimg.com 游戏娱乐 24 27 2481 24681 200 13631579950 13826544101 5C-0E-8B-C7-F1...
MapReduce之自定义分组
若兰幽竹
05-25 613
MapReduce之自定义分组一、需求说明二、测试数据三、编程思路四、实现步骤五、打包上传到集群中运行 一、需求说明 说明： 分组是一种特殊的比较器，对key做比较，并进行归并，类似于合并同类项，也类似于SQL中的分组查询 要求： 通过自定义分组比较器实现将emp.csv中的数据按照部门号分成三个分组，并显示出每组的人员名称， 最终显示的结果格式如下所示： <10,CLARK1；KING1；MILLER1> <20,CLARK2；KING2；MILLER2> <30,CLA
MapReduce自定义分组实现
everl_1的专栏
09-04 2088
当mapreduce没有自定义分组时，map中所有的key被分为一组，其分组操作默认是走的HashPartitioner： public class HashPartitioner extends Partitioner { /** Use {@link Object#hashCode()} to partition. */ public int getPartition(K key,
Python开发mapreduce的demo
07-13
总的来说，这个Python MapReduce的demo提供了一个基础的框架，帮助开发者理解如何在Python中实现MapReduce的流程。通过学习和实践这个示例，你可以更好地掌握分布式计算的核心思想，并将其应用到更复杂的大型数据...
HadoopDemo_hadoopDemo_nationhb8_hadoop_源码
10-04
《深入剖析HadoopDemo：Java API与MapReduce编程实践》 在大数据处理领域，Hadoop作为开源框架，因其分布式计算的强大能力而备受瞩目。本文将深入探讨如何利用Java API操作HDFS（Hadoop Distributed File System）...
hive自定义函数demo
05-30
本示例“hive自定义函数demo”将探讨如何在Hive中开发和使用自定义函数（UDF），这对于扩展Hive的功能和适应特定业务需求至关重要。下面，我们将深入学习与Hive自定义函数相关的知识。 1. **什么是Hive UDF?** ...
wordcount_demo
11-03
"wordcount_demo"是一个典型的MapReduce示例，它展示了如何利用Hadoop处理大数据的基本步骤。在这个例子中，我们的目标是统计文本中每个单词出现的次数，这是一个非常基础但具有代表性的任务，适合初学者理解和学习...
一个MapReduce简单程序示例
05-28
Combiner是MapReduce中的一个优化策略，它可以在Reduce之前对Map的输出进行局部聚合。在上述示例中，可能已经在Map阶段使用了Combiner来减少数据传输量，提高整体性能。 总结来说，MapReduce是处理大数据的关键工具...
MapReduce2中自定义排序分组
08-12
NULL 博文链接：https://username2.iteye.com/blog/2274802
mapreduce wc单词计数 自定义分区 自定义排序实现
09-07
实现mr的wordcount功能和自定义分区的功能、自定义排序功能；com.ellis.mr1为类似wc功能，com.ellis.mr2为自定义分区功能，com.ellis.mr3为自定义排序功能
MapReduce的自定义分组
weixin_30929011的博客
02-07 113
1 package com.mengyao.hadoop.mapreduce; 2 3 import java.io.IOException; 4 import java.text.SimpleDateFormat; 5 import java.util.Date; 6 7 import org.apache.hadoop.conf.Configur...
MapReduce的自定义排序、分区和分组
axs441702的博客
05-17 519
自定义排序（WritableComparable） 当写mr程序来处理文本时，经常会将处理后的信息封装到我们自定义的bean中，并将bean作为map输出的key来传输 而mr程序会在处理数据的过程中（传输到reduce之前）对数据排序（如：map端生成的文件中的内容分区且区内有序）。 操作： 自定义bean来封装处理后的信息，可以自定义排序规则用bean中的某几个属性来作为排序...
mapreduce的自定义分组器
lds_include
06-18 773
Mapreduce自定义分组器 前提：有的时候我们想将符合条件的key值放在同一个组内；但是key的值是不同的将不会放进同一个组中。 举例：想将一个学生的进校以后不同时间段的数学成绩按进校考试的时间进行一个成绩排序。如下效果 //排序前的效果 stu1 time1 core1 stu1 time2 core stu1 time3 core3 stu2 time1 core1 stu2 t...
mapreduce分组统计_一种基于MapReduce的Map端数据的聚合方法与流程
weixin_35928736的博客
01-13 855
本发明涉及的是一种分布式计算方法，具体涉及一种基于MapReduce的Map端数据的聚合方法。背景技术：当前处理大数据应用问题时，比较重要的两个思想：并行和分治。通过将大规模的数据合理的拆分成多个小部分，通过并行思想和分治思想相结合的计算方法，使得问题得到的相对满意的解决。MapReduce为我们提供了一种有效、快速的并行编程框架。MapReduce实现了两个主要功能：Map和Reduce。Map...
MapReduce实战小案例（自定义排序、二次排序、分组、分区）
fengxiandada的博客
06-26 6946
MapReduce实战小案例
「 Hadoop」mapreduce对温度数据进行自定义排序、分组、分区等
知之可否
03-14 3802
转自  http://www.ptbird.cn/mapreduce-tempreture.html 一、需求说明 1、数据文件说明 hdfs中有一些存储温度的数据文件，以文本形式存储，示例如下： 日期和时间中间是空格，为整体，表示检测站点监测的时间，后面是检测的温度，中间通过制表符 \t 相隔。 2、需求 计算在1949-1955年中,
MapReduce：分区与分组
Jodness' Blogs
05-29 3216
分区、分组 分区：在Mapper的输出时进行，默认会采用HashPartitioner，会根据key值和reduce数进行分组；在写入MapOutputBuffer的缓冲区之前每个kv对就已经获取了对应的分区索引，在溢写时默认会根据分区索引从小到大，key值从小到大进行排序；并且rudecer数决定了分区数量，因为一个reducer只能处理一个分区。自定义分组器通过Job.setPartitio...
16、MapReduce的基本用法示例-自定义序列化、排序、分区、分组和topN
最新发布
05-29
本文介绍了MapReduce的基本用法示例，主要包括自定义序列化、排序、分区、分组和topN。在使用这些功能之前，需要确保hadoop环境正常运行。 首先，在介绍具体用法之前，作者先介绍了项目的pom.xml文件和测试数据说明...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值