MapReduce知识点（2）

最新推荐文章于 2021-08-24 11:44:28 发布
最新推荐文章于 2021-08-24 11:44:28 发布
阅读量243 收藏
点赞数
文章标签： hadoop mapreduce 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AnswerLinWJ/article/details/115084860
版权

计数器

在这里插入图片描述

  1. 内置计数器

在这里插入图片描述

  1. 定义计数器

    1. 使用上下文对象context的getCounter方法，两个参数，计数器类型和名字
    2. 枚举创建

排序和序列化

在这里插入图片描述

原数据：

在这里插入图片描述

需求：

  • 第一列按字典顺序进行排列
  • 第一列相同时，第二列按升序进行排序

  1. 定义sortbean类实现WritableComparable接口,按照需求定义成员变量，重写compareTo方法和write、readFields方法

    package com.bigdata.mapreduce.sort;

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class sortbean implements WritableComparable<sortbean> {

    private String word;
    private int num;

    //实现比较器，指定比较规则
    /*
        排序规则：先排第一个，按字典顺序
        第一个相同，第二列按升序排
     */
    @Override
    public int compareTo(sortbean o) {
        //将成员和传进来的进行比较,对第一列排序
        //compareTo 字符串自带方法
        int result = this.word.compareTo(o.word);
        //如果第一列相同则按照第二列进行排序
        //升序
        //正数则说明this.num比o.num大将this.num放在后面
        //负数则说明this.num比o.num小将this.num放在前面
        if(result == 0){
            return this.num - o.num;
        }
        return result;
    }

    //实现序列化
    @Override
    public void write(DataOutput dataOutput) throws IOException {
        //write后看成员是上面类型
        //固定步骤
        dataOutput.writeUTF(word);
        dataOutput.writeInt(num);
    }

    //反序列化
    @Override
    public void readFields(DataInput dat0aInput) throws IOException {
        //固定步骤
        this.word = dat0aInput.readUTF();
        this.num = dat0aInput.readInt();
    }

    public String getWord() {
        return word;
    }

    public void setWord(String word) {
        this.word = word;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return word + '\t' + num ;
    }
}

  2. mapper类

    package com.bigdata.mapreduce.sort;

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

import java.io.IOException;

public class s_mapper extends
        Mapper<LongWritable, Text,sortbean, NullWritable> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //将文本数据V1拆分，并封装到sortbean对象
        String[] split = value.toString().split("\t");
        sortbean sb = new sortbean();
        sb.setWord(split[0]);
        sb.setNum(Integer.parseInt(split[1]));
        //将K2,V2写入上下问对象
        context.write(sb,NullWritable.get());
    }
}

  3. Reducer类

    package com.bigdata.mapreduce.sort;

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

import java.io.IOException;

public class s_reducer extends
        Reducer<sortbean, NullWritable,sortbean,NullWritable> {
    @Override
    protected void reduce(sortbean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        context.write(key,NullWritable.get());
    }
}

  4. 主类

    package com.bigdata.mapreduce.sort;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class s_job extends Configured implements Tool {
    @Override
    public int run(String[] strings) throws Exception {
        //创建job对象
        Job job = Job.getInstance(super.getConf(),"flow");

        //配置job对象
        //1. 配置输入类和输入路径
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path("file:///D:\\mapreduce_demo\\input"));

        //2. 设置mapper类和数据类型（K2,V2）
        job.setMapperClass(s_mapper.class);
        job.setMapOutputKeyClass(sortbean.class);
        job.setMapOutputValueClass(NullWritable.class);
        //3. 分区
        //4.排序
            //当定义了sortbean类后在类中制定了排序规则，无需做其他操作
        //5.规约 6.分组

        //7. 设置reducer类和数据类型（K3,V3）
        job.setReducerClass(s_reducer.class);
        job.setOutputKeyClass(sortbean.class);
        job.setOutputValueClass(NullWritable.class);
        //8.设置输出类型和路径
        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job,new Path("file:///D:\\mapreduce_demo\\sort_out"));

        //等待任务结束
        boolean flag = job.waitForCompletion(true);

        return flag ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {
        Configuration entries = new Configuration();
        int run = ToolRunner.run(entries, new s_job(), args);
        System.exit(run);
    }
}

规约

在这里插入图片描述

在这里插入图片描述

综合案例

在这里插入图片描述

  1. flowbean

    package com.bigdata.mapreduce.example1;

import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class flowbean implements Writable {
    private Integer upFlow;
    private Integer downFlow;
    private Integer upCountFlow;
    private Integer downCountFlow;


    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeInt(upFlow);
        dataOutput.writeInt(downFlow);
        dataOutput.writeInt(upCountFlow);
        dataOutput.writeInt(downCountFlow);
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.upFlow = dataInput.readInt();
        this.downFlow = dataInput.readInt();
        this.upCountFlow = dataInput.readInt();
        this.downCountFlow = dataInput.readInt();
    }

    public Integer getUpFlow() {
        return upFlow;
    }

    public void setUpFlow(Integer upFlow) {
        this.upFlow = upFlow;
    }

    public Integer getDownFlow() {
        return downFlow;
    }

    public void setDownFlow(Integer downFlow) {
        this.downFlow = downFlow;
    }

    public Integer getUpCountFlow() {
        return upCountFlow;
    }

    public void setUpCountFlow(Integer upCountFlow) {
        this.upCountFlow = upCountFlow;
    }

    public Integer getDownCountFlow() {
        return downCountFlow;
    }

    public void setDownCountFlow(Integer downCountFlow) {
        this.downCountFlow = downCountFlow;
    }

    @Override
    public String toString() {
        return  upFlow +
                "\t" + downFlow +
                "\t" + upCountFlow +
                "\t" + downCountFlow
                ;
    }
}

  2. mapper

    package com.bigdata.mapreduce.example1;

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

import java.io.IOException;

public class FlowCountMapper extends
        Mapper<LongWritable, Text,Text,flowbean> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] split = value.toString().split("\t");
        flowbean fb = new flowbean();
        Text text = new Text(split[1]);
        fb.setUpFlow(Integer.parseInt(split[6]));
        fb.setDownFlow(Integer.parseInt(split[7]));
        fb.setUpCountFlow(Integer.parseInt(split[8]));
        fb.setDownCountFlow(Integer.parseInt(split[9]));
        context.write(text,fb);

    }
}

  3. reducer

    package com.bigdata.mapreduce.example1;

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

import java.io.IOException;

public class FlowCountReducer extends
        Reducer<Text, flowbean, Text, flowbean> {
    @Override
    protected void reduce(Text key, Iterable<flowbean> values, Context context) throws IOException, InterruptedException {
        flowbean fb = new flowbean();
        Integer upFlow = 0;
        Integer downFlow = 0;
        Integer upCountFlow = 0;
        Integer downCountFlow = 0;
        for (flowbean f : values) {
            upFlow += f.getUpFlow();
            downFlow += f.getDownFlow();
            upCountFlow += f.getUpCountFlow();
            downCountFlow += f.getDownCountFlow();
        }
        fb.setUpFlow(upFlow);
        fb.setDownFlow(downFlow);
        fb.setUpCountFlow(upCountFlow);
        fb.setDownCountFlow(downCountFlow);
        context.write(key,fb);
    }
}

  4. jobmain

    package com.bigdata.mapreduce.example1;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
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.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class FlowJobMain extends Configured implements Tool {
    @Override
    public int run(String[] strings) throws Exception {
        //创建job任务对象
        Job job = Job.getInstance(super.getConf(),"example1");
        //设置job配置
        //设置job输入类型和路径
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path(""));
        //设置mapper类和数据类型（K2,V2）
        job.setMapperClass(FlowCountMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(flowbean.class);
        //分区、排序、规约、分组
        //设置reducer类和数据类型（K3,V3）
        job.setReducerClass(FlowCountReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(flowbean.class);
        //设置输入类型和路径
        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job,new Path(""));
        //等待任务结束
        boolean flag = job.waitForCompletion(true);
        return flag?0:1;
    }

    public static void main(String[] args) throws Exception {
        Configuration entries = new Configuration();
        int run = ToolRunner.run(entries, new FlowJobMain(), args);
        System.exit(run);
    }
}

在这里插入图片描述

  1. FlowBean

    package com.bigdata.mapreduce.example2;

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class FlowBean implements WritableComparable<FlowBean> {
    private Integer upFlow;
    private Integer downFlow;
    private Integer upCountFlow;
    private Integer downCountFlow;

    @Override
    public int compareTo(FlowBean o) {
        return o.upFlow - this.upFlow;
    }

    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeInt(upFlow);
        dataOutput.writeInt(downFlow);
        dataOutput.writeInt(upCountFlow);
        dataOutput.writeInt(downCountFlow);
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.upFlow = dataInput.readInt();
        this.downFlow = dataInput.readInt();
        this.upCountFlow = dataInput.readInt();
        this.downCountFlow = dataInput.readInt();
    }

    public Integer getUpFlow() {
        return upFlow;
    }

    public void setUpFlow(Integer upFlow) {
        this.upFlow = upFlow;
    }

    public Integer getDownFlow() {
        return downFlow;
    }

    public void setDownFlow(Integer downFlow) {
        this.downFlow = downFlow;
    }

    public Integer getUpCountFlow() {
        return upCountFlow;
    }

    public void setUpCountFlow(Integer upCountFlow) {
        this.upCountFlow = upCountFlow;
    }

    public Integer getDownCountFlow() {
        return downCountFlow;
    }

    public void setDownCountFlow(Integer downCountFlow) {
        this.downCountFlow = downCountFlow;
    }

    @Override
    public String toString() {
        return  upFlow +
                "\t" + downFlow +
                "\t" + upCountFlow +
                "\t" + downCountFlow
                ;
    }
}

  2. mapper

    package com.bigdata.mapreduce.example2;

import com.bigdata.mapreduce.example1.flowbean;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class smapper extends
        Mapper<LongWritable, Text,FlowBean,Text> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] split = value.toString().split("\t");
        FlowBean fb = new FlowBean();
        Text text = new Text(split[0]);
        fb.setUpFlow(Integer.parseInt(split[1]));
        fb.setDownFlow(Integer.parseInt(split[2]));
        fb.setUpCountFlow(Integer.parseInt(split[3]));
        fb.setDownCountFlow(Integer.parseInt(split[4]));
        context.write(fb,text);
    }
}

  3. reducer

    package com.bigdata.mapreduce.example2;

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

import java.io.IOException;

public class sreducer extends
        Reducer<FlowBean, Text,Text,FlowBean> {
    @Override
    protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        for (Text value : values) {
            context.write(value,key);
        }
    }
}

  4. jobmain

    package com.bigdata.mapreduce.example2;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
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.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class sjobmain extends Configured implements Tool {
    @Override
    public int run(String[] strings) throws Exception {
        Job job = Job.getInstance(super.getConf(),"sortflow");
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path(""));
        job.setMapperClass(smapper.class);
        job.setMapOutputKeyClass(FlowBean.class);
        job.setMapOutputValueClass(Text.class);
        //3 4 5 6
        job.setReducerClass(sreducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);
        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job,new Path(""));
        boolean flag = job.waitForCompletion(true);
        return flag?0:1;
    }

    public static void main(String[] args) throws Exception {
        Configuration entries = new Configuration();
        int run = ToolRunner.run(entries, new sjobmain(), args);
        System.exit(run);
    }
}

在这里插入图片描述

在需求1的基础上添加分区类对主类进行修改即可

  1. partitioner

    package com.bigdata.mapreduce.example3;

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

public class flowPartitioner extends
        Partitioner<Text,flowbean> {
    @Override
    public int getPartition(Text text, flowbean flowbean, int i) {
        if(text.toString().startsWith("135")){
            return 0;
        }else if (text.toString().startsWith("136")){
            return 1;
        }else if (text.toString().startsWith("137")){
            return 2;
        }else{
            return 3;
        }
    }
}

  2. jobmain

    package com.bigdata.mapreduce.example3;

import com.bigdata.mapreduce.example1.FlowCountMapper;
import com.bigdata.mapreduce.example1.FlowCountReducer;
import com.bigdata.mapreduce.example1.flowbean;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
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.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class FlowJobMain extends Configured implements Tool {
    @Override
    public int run(String[] strings) throws Exception {
        //创建job任务对象
        Job job = Job.getInstance(super.getConf(),"flow");
        //设置job配置
        //设置job输入类型和路径
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path(""));
        //设置mapper类和数据类型（K2,V2）
        job.setMapperClass(FlowCountMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(flowbean.class);
        //分区、排序、规约、分组
       //设置分区类
        job.setPartitionerClass(flowPartitioner.class);
        //设置分区数
        job.setNumReduceTasks(4);

        //设置reducer类和数据类型（K3,V3）
        job.setReducerClass(FlowCountReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(flowbean.class);
        //设置输入类型和路径
        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job,new Path(""));
        //等待任务结束
        boolean flag = job.waitForCompletion(true);
        return flag?0:1;
    }

    public static void main(String[] args) throws Exception {
        Configuration entries = new Configuration();
        int run = ToolRunner.run(entries, new FlowJobMain(), args);
        System.exit(run);
    }
}

MapReduce知识点（1）
MapReduce知识点（2）
MapReduce知识点（3）
MapReduce知识点（4）

_知多少_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MapReduce实例（一）
chenxiaoqiong的专栏
03-17 4292
原文地址：http://chenxiaoqiong.com/articles/mapreduce1/ 基本概念 Hadoop:的框架最核心的设计就是：HDFS和MapReduce。HDFS为海量的数据提供了存储，则MapReduce为海量的数据提供了计算。 MapReduce:是处理大量半结构化数据集合的编程模型。最简单的 MapReduce应用程序至少包含 3 个部分：一个 Map 函
Tool接口对MapReduce进行优化
曾一航bd
10-04 402
继承Configured，实现Tool，不在run方法中new Configuration，调用run时，用ToolRunner调用 package com.kfk.hadoop.mr; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.conf.Configured; import org.apach...
MapReduce Tool 接口
实践求真知
12-21 1232
一 关于Tool 接口的MapReduce编码 1 自定义序列化类 package com.cakin.hadoop.mr; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import org.apache.hadoop.io.WritableComparable; public
MapReduce学习笔记
吃果冻不吐果冻皮
08-18 2914
一、MapReduce概述 MapReduce 是 Hadoop 的核心组成, 是专用于进行数据计算的，是一种分布式计算模型，由Google提出，主要用于搜索领域，解决海量数据的计算问题.MapReduce由两个阶段组成：Map和Reduce，用户只需要实现map()和reduce()两个函数，即可实现分布式计算，非常简单。这两个函数的形参是key、value对，表示函数的输入输出信息。 ma
MAPREDUCE加强
何星平的博客
06-18 123
流量统计相关需求 1、对流量日志中的用户统计总上、下行流量 技术点： 自定义javaBean用来在mapreduce中充当value 注意： javaBean要实现Writable接口，实现两个方法 //序列化，将对象的字段信息写入输出流 @Override public void write(DataOutput out) throws IOException { out.wri...
HBase核心知识点总结
01-27
【HBase核心知识点总结】 HBase，作为一款基于Hadoop的分布式数据库，是解决大规模数据存储和快速访问问题的关键工具。其主要特点是稀疏性、分布式、持久化和多维有序映射，通过行键、列键和时间戳进行索引，支持...
JAVA全栈核心知识点整理-面试
06-21
在准备JAVA全栈核心知识点的面试时，理解并掌握以下几个关键领域是至关重要的： 1. **JVM（Java虚拟机）**：JVM是Java程序的运行环境，它负责类的加载、验证、执行字节码以及垃圾回收。了解JVM内存模型（包括堆、栈...
知识点整理_for_software.zip
01-17
《软件设计师一本通_精华知识点(重要必看).pdf》是针对软件设计领域的核心知识点进行系统整理的参考资料，旨在帮助学习者深入理解并掌握软件设计的关键概念和技术。这份压缩包中的文档涵盖了软件设计的多个重要方面...
大数据技术知识点概要
10-30
对林子雨老师的大数据原理与应用课程的总结，基本是个人的理解，包括了对各个术语的解释。帮助读者入门大数据。
基础MapReduce程序骨架
jokes000的专栏
12-14 2126
/*************************************************** * MapReduce Basic Template * Author: jokes000 * Date: 2011-12-14 * Version: 1.0.0 **************************************************/ public
MapReduce模板的编写
super-yong的博客
03-04 269
我们根据wordcount的mapreduce程序来编写一个MapReduce的通用模板，方便之后的使用： 首先说明一下之前的博客中有提到过有三种编写MapReduce的模板： --------------------------------------------------------------------- 三种编写MapReduce模板： Driver： -...
Hadoop入门系列(4) -- MapReduce详解
只争朝夕
07-02 651
Map过程 Reduce过程 MapReducce使用技巧
MapReduce编程五步走
捕影世界
01-16 500
MapReduce全过程的数据都是以键值对的形式存在的 hive spark hive hbase hadoop hive spark sqoop flume scala 这里涉及到一个偏移量（一个字符或空格为1位）  第一行的偏移量为0，内容为“hive spark hive hbase”  第二行的偏移量为21，内容为“hadoop hive spark”  第三行的偏移量为39，内...
MR高级编程
qq_55917208的博客
08-24 566
一、MR中的Counter计数器
MapReduce-Counter使用
u011007180的博客
08-21 4199
在普通的java程序中我们可以定义一个全局的静态变量，然后我们可以在各个类中去使用，实现累加器的功能，然而在mapruduce中怎么实现这一功能呢，各个map可能运行在不同的JVM中（这里不考虑JVM重用的情况），然而我们可以借助MapReduce提供的Counter功能来实现这一功能，下面我们通过一个实例来说明这一个用法。 实验要求：快速实现文件行数，以及其中错误记录的统计 实验数据： 1
MapReduce:默认Counter的含义
weixin_33975951的博客
01-16 147
MapReduce Counter为提供我们一个窗口：观察MapReduce job运行期的各种细节数据。今年三月份期间，我曾经专注于MapReduce性能调优工作，是否优化的绝大多评估都是基于这些Counter的数值表 现。MapReduce自带了许多默认Counter，可能有些朋友对它们有些疑问，现在我分析下这些默认Counter的含义，方便大家观察job结 果。     我的分析是基于H...
mapreduce中counter的使用
weixin_34315189的博客
05-13 407
MapReduce Counter为提供我们一个窗口：观察MapReduce job运行期的各种细节数据。MapReduce自带了许多默认Counter。 Counter有"组group"的概念，用于表示逻辑上相同范围的所有数值。MapReduce job提供的默认Counter分为三个组 Map-Reduce Frameword M...
MapReduce-Counter使用-快速实现大文件行数的统计
Qi.zheng
03-25 9248
在普通的java程序中我们可以定义一个全局的静态变量，然后我们可以在各个类中去使用，实现累加器的功能，然而在mapruduce中怎么实现这一功能呢，各个map可能运行在不同的JVM中（这里不考虑JVM重用的情况），然而我们可以借助MapReduce提供的Counter功能来实现这一功能，下面我们通过一个实例来说明这一个用法。 实验要求：快速实现文件行数，以及其中错误记录的统计 实验数据： 1
Java中的List<JavaBean>以javabean中的某一属性排序之Collections.sort方法
千弘
07-28 949
项目中遇到一个需求：排序 怎么排呢？以javabean中的日期排序，我首先想到的就是冒泡排序。后来试了一下，麻烦还不好使。 于是，就使用了Java中的Collections.sort方法 具体如下 //把数据进行排序 public void sortData(ListSYSBBZT> filteredData) { Collections.sort(filteredData,
mapreduce的高级知识点
最新发布
07-27
- *1* *2* *3* [分布式计算模型MapReduce 基础知识点](https://blog.csdn.net/weixin_44589991/article/details/115014112)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值