无法将java.lang.Object转换为自己的类

我是java/hadoop新手，目前正在尝试重新创建我在此处找到的代码的结果：

与示例相反，我只有3个“列”，每个列都有一个整数，由制表符（/t）分隔，例如100 115 3 前两个数字是节点，第三个是节点之间的权重。现在，我尝试查找第一个节点的最小和最大权重。 我在代码中唯一更改的是分隔符（/t），并且我将两个类放在一个文件中（我读到的应该是ok）。 现在我在下面指示的行中得到一个错误“java.lang.Object无法转换为minmaxduration”。 我发现了类似的问题，比如 但这并没有真正帮助我。我怎样才能解决这个问题？ 提前谢谢

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

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.io.*;
import org.apache.hadoop.util.*;

import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class Q1{

  public static class DurationMapper
       extends Mapper<Object, Text, Text, MinMaxDuration>{

    private Text month= new Text();
    private Integer minduration;
    private Integer maxduration;


    private MinMaxDuration outPut= new MinMaxDuration();

    public void map(Object key, Text value, Context context
                    ) throws IOException, InterruptedException {

        String[] campaignFields= value.toString().split("/t");
        //10001,'telephone','may','mon',100,1,999,0,'nonexistent','no',0
        month.set(campaignFields[0]);
        minduration=Integer.parseInt(campaignFields[2]);
        maxduration=Integer.parseInt(campaignFields[2]);

        if (month == null || minduration == null || maxduration== null) {
            return;
        }   
        try {
            outPut.setMinDuration(minduration);
            outPut.setMaxDuration(maxduration);
            context.write(month,outPut);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
     }
  }

  public static class DurationReducer
       extends Reducer<Text,MinMaxDuration,Text,MinMaxDuration> {
      private MinMaxDuration resultRow = new MinMaxDuration();

     public void reduce(Text key, Iterable values,
                       Context context
                       ) throws IOException, InterruptedException {
      Integer minduration = 0;
      Integer maxduration = 0;

      resultRow.setMinDuration(null);
      resultRow.setMaxDuration(null);

      for (MinMaxDuration val : values) { //ERROR HERE

          minduration = val.getMinDuration();
          maxduration = val.getMaxDuration();
          // get min score 
          if (resultRow.getMinDuration()==null || minduration.compareTo(resultRow.getMinDuration())<0) {
        resultRow.setMinDuration(minduration);
        }            
      // get min bonus                       
      if (resultRow.getMaxDuration()==null || maxduration.compareTo(resultRow.getMaxDuration())>0) {
            resultRow.setMaxDuration(maxduration);
        }
       } // end of for loop
     context.write(key, resultRow);
    }
  }

  public static void main(String[] args) throws Exception {
    Configuration conf = new Configuration();
    Job job = Job.getInstance(conf, "Campaign Duration Count");
    job.setJarByClass(CampaignMinMax.class);
    job.setMapperClass(DurationMapper.class);
    job.setCombinerClass(DurationReducer.class);
    job.setReducerClass(DurationReducer.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(MinMaxDuration.class);
    FileInputFormat.addInputPath(job, new Path(args[0]));
    FileOutputFormat.setOutputPath(job, new Path(args[1]));
    System.exit(job.waitForCompletion(true) ? 0 : 1);
  }
}

class MinMaxDuration implements Writable {
    // declare variables
    Integer minDuration;
    Integer maxDuration;
    // constructor
    public MinMaxDuration() {
        minDuration=0;
        maxDuration=0;
    }
    //set method
    void setMinDuration(Integer duration){
        this.minDuration=duration;
    }
    void setMaxDuration(Integer duration){
        this.maxDuration=duration;
    }
    //get method
    Integer getMinDuration() {
        return minDuration;
    }
    Integer getMaxDuration(){
        return maxDuration;
    }

    // write method
            public void write(DataOutput out) throws IOException {
            // what order we want to write !
                out.writeInt(minDuration);
                out.writeInt(maxDuration);
        }

         // readFields Method
        public void readFields(DataInput in) throws IOException {
            minDuration=new Integer(in.readInt());
            maxDuration=new Integer(in.readInt());
        }

        public String toString() {
            return minDuration + "\t" + maxDuration;
        }

  }

import java.io.IOException；
导入java.io.DataInput；
导入java.io.DataOutput；
导入org.apache.hadoop.fs.Path；
导入org.apache.hadoop.conf.Configuration；
导入org.apache.hadoop.io.*；
导入org.apache.hadoop.util.*；
导入org.apache.hadoop.mapreduce.Job；
导入org.apache.hadoop.mapreduce.Mapper；
导入org.apache.hadoop.mapreduce.Reducer；
导入org.apache.hadoop.mapreduce.lib.input.FileInputFormat；
导入org.apache.hadoop.mapreduce.lib.output.FileOutputFormat；
公开课Q1{
公共静态类DurationMapper
扩展映射器{
私有文本月份=新文本（）；
私人整体思维；
私有整数maxduration；
私有MinMaxDuration输出=新的MinMaxDuration（）；
公共无效映射（对象键、文本值、上下文
)抛出IOException、InterruptedException{
字符串[]活动字段=value.toString（）.split（“/t”）；
//10001、‘电话’、‘五月’、‘星期一’、100、1999、0、‘不存在’、‘不存在’、0
月集（活动字段[0]）；
minduration=Integer.parseInt（活动字段[2]）；
maxduration=Integer.parseInt（活动字段[2]）；
如果（月==null | |持续时间==null | |最大持续时间==null）{
返回；
}   
试一试{
输出。设定持续时间（minduration）；
outPut.setMaxDuration（maxduration）；
context.write（月，输出）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
公共静态类DurationReducer
伸缩减速机{
私有MinMaxDuration resultRow=新的MinMaxDuration（）；
public void reduce（文本键、Iterable值、，
语境
)抛出IOException、InterruptedException{
整数minduration=0；
整数maxduration=0；
resultRow.setMinDuration（空）；
resultRow.setMaxDuration（null）；
对于（MinMaxDuration val:values）{//此处出错
minduration=val.getMinDuration（）；
maxduration=val.getMaxDuration（）；
//得分最低
如果（resultRow.getMinDuration（）==null | | minduration.compareTo（resultRow.getMinDuration（））0）{
resultRow.setMaxDuration（maxduration）；
}
}//for循环结束
write（key，resultRow）；
}
}
公共静态void main（字符串[]args）引发异常{
Configuration conf=新配置（）；
Job Job=Job.getInstance（conf，“活动持续时间计数”）；
job.setJarByClass（activityminmax.class）；
setMapperClass（DurationMapper.class）；
job.setCombinerClass（DurationReducer.class）；
job.setReducerClass（DurationReducer.class）；
job.setOutputKeyClass（Text.class）；
job.setOutputValueClass（MinMaxDuration.class）；
addInputPath（作业，新路径（args[0]）；
setOutputPath（作业，新路径（args[1]）；
系统退出（作业等待完成（真）？0:1；
}
}
类MinMaxDuration实现可写{
//声明变量
整体思维；
整数最大持续时间；
//建造师
公共MinMaxDuration（）{
专注度=0；
maxDuration=0；
}
//集合方法
无效设置持续时间（整数持续时间）{
这一点：持续时间=持续时间；
}
void setMaxDuration（整数持续时间）{
这个.maxDuration=持续时间；
}
//获取方法
整数getMinDuration（）{
回归思维；
}
整数getMaxDuration（）{
返回最大持续时间；
}
//写入方法
public void write（DataOutput out）引发IOException{
//我们想写什么样的命令！
出、写（念）；
out.writeInt（最大持续时间）；
}
//readFields方法
public void readFields（DataInput in）引发IOException{
minDuration=新整数（in.readInt（））；
maxDuration=新整数（in.readInt（））；
}
公共字符串toString（）{
返回minDuration+“\t”+maxDuration；
}
}

方法签名中缺少类型规范。因此，它将被视为一个通用的

对象

，而不是您的具体类型。因此，将方法签名从

public void reduce(Text key, Iterable values,Context context) throws IOException, InterruptedException 

到

public void reduce（文本键、Iterable值、，
语境
)抛出IOException、InterruptedException

---

所以您指定了正确的类型

你有没有试着为Iterable指定类型？喜欢Iterable吗？嗨，克里斯，谢谢你的回答。如果我这样做，我会得到“java.lang.Object无法转换为java.lang.Iterable”嗨，克里斯，非常感谢！对不起，我误解了，把Iterable放在了错误行中。它适用于“public void reduce”（文本键，Iterablebummer，我的输出为空，但代码可以工作…您可以接受答案

public void reduce(Text key, Iterable<MinMaxDuration> values,
                   Context context
                   ) throws IOException, InterruptedException