java map数组遍历

Map的遍历可以使用不同的方法，包括普通for循环遍历、forEach循环遍历和Lambda表达式遍历等方式。

普通for循环遍历：

System.out.println("第一种方式：普通for循环遍历 Map 数组");
for (Map.Entry<K, V> entry : map.entrySet()) {
    K key = entry.getKey();
    V value = entry.getValue();
    System.out.println("Key: " + key + ", Value: " + value);
}

forEach循环遍历：

System.out.println("\n第二种方式：forEach循环遍历 Map 数组");
map.forEach((key, value) -> {
    System.out.println("Key: " + key + ", Value: " + value);
});

Lambda表达式遍历：

System.out.println("\n第三种方式：Lambda表达式遍历 Map 数组");
map.entrySet().stream().forEach(entry -> {
    System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
});

相关问题

Mapreduce 求每个学科的平均分，学科作为行键，成绩作为列族，如何创建一个数组遍历成绩

在 MapReduce 中，输入数据通常以键值对的形式表示。对于本题，我们可以将学科作为键，成绩作为值，例如：

Mathematics  85
English      72
Mathematics  90
Science      78
English      83

为了计算每个学科的平均分，我们需要将相同学科的成绩累加起来，然后计算平均值。在 Mapper 阶段，我们可以将学科作为键，成绩作为值，输出键值对。在 Reducer 阶段，我们可以对相同学科的所有成绩进行累加，并计算平均值。

下面是一个简单的示例代码，假设输入数据已经按照学科排序：

public static class AvgScoreMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    private Text subject = new Text();
    private IntWritable score = new IntWritable();

    @Override
    public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] parts = value.toString().split("\\s+");
        subject.set(parts[0]);
        score.set(Integer.parseInt(parts[1]));
        context.write(subject, score);
    }
}

public static class AvgScoreReducer extends Reducer<Text, IntWritable, Text, DoubleWritable> {

    private DoubleWritable avgScore = new DoubleWritable();

    @Override
    public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        int count = 0;
        for (IntWritable value : values) {
            sum += value.get();
            count++;
        }
        double avg = (double) sum / count;
        avgScore.set(avg);
        context.write(key, avgScore);
    }
}

在 Mapper 中，我们首先将输入数据按空格分割成数组，然后将数组的第一个元素作为学科，第二个元素作为成绩，将学科和成绩分别设置到 `Text` 和 `IntWritable` 对象中，并输出键值对。

在 Reducer 中，我们首先对相同学科的所有成绩进行累加，并记录成绩的个数。然后计算平均值，将学科和平均值分别设置到 `Text` 和 `DoubleWritable` 对象中，并输出键值对。

在以上示例代码中，并没有使用数组来遍历成绩。在 MapReduce 中，我们通常使用迭代器来遍历值的集合。在 Reducer 中，输入的值是一个 `Iterable` 对象，可以使用 `for` 循环遍历所有的成绩。在示例代码中，我们使用增强型 `for` 循环来遍历值的集合。

Mapreduce 求每个学科的平均分，学科作为行键，成绩作为列族，如何创建一个数组遍历成绩。用hbase

如果你想使用数组来遍历成绩，可以在 Mapper 中将成绩存储到一个数组中，输出时将数组作为值输出。在 Reducer 中，输入的值是一个数组，可以使用 `for` 循环遍历所有的成绩。

下面是一个简单的示例代码，假设 HBase 中的表名为 `scores`，有一个列族 `cf`，列名为 `score`，存储学科成绩。我们需要计算每个学科的平均分，学科作为键，成绩作为列族。

public static class AvgScoreMapper extends TableMapper<Text, IntArrayWritable> {

    private Text subject = new Text();
    private IntWritable[] scores = new IntWritable[10];

    @Override
    public void map(ImmutableBytesWritable rowKey, Result result, Context context) throws IOException, InterruptedException {
        String subjectStr = new String(rowKey.get());
        subject.set(subjectStr);
        byte[] scoreBytes = result.getValue(Bytes.toBytes("cf"), Bytes.toBytes("score"));
        int scoreInt = Bytes.toInt(scoreBytes);
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] == null) {
                scores[i] = new IntWritable(scoreInt);
                break;
            }
        }
    }

    @Override
    protected void cleanup(Context context) throws IOException, InterruptedException {
        context.write(subject, new IntArrayWritable(scores));
    }
}

public static class AvgScoreReducer extends Reducer<Text, IntArrayWritable, Text, DoubleWritable> {

    private DoubleWritable avgScore = new DoubleWritable();

    @Override
    public void reduce(Text key, Iterable<IntArrayWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        int count = 0;
        for (IntArrayWritable value : values) {
            IntWritable[] scores = (IntWritable[]) value.get();
            for (IntWritable score : scores) {
                if (score != null) {
                    sum += score.get();
                    count++;
                }
            }
        }
        double avg = (double) sum / count;
        avgScore.set(avg);
        context.write(key, avgScore);
    }
}

public static void main(String[] args) throws Exception {
    Configuration conf = HBaseConfiguration.create();
    Job job = Job.getInstance(conf, "AvgScore");
    job.setJarByClass(AvgScore.class);

    Scan scan = new Scan();
    scan.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("score"));
    TableMapReduceUtil.initTableMapperJob("scores", scan, AvgScoreMapper.class, Text.class, IntArrayWritable.class, job);
    job.setReducerClass(AvgScoreReducer.class);
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(DoubleWritable.class);

    System.exit(job.waitForCompletion(true) ? 0 : 1);
}

在 Mapper 中，我们首先将行键转换成字符串，作为学科；然后从 `Result` 中取出 `cf:score` 列的值，将其转换成整数类型，存储到数组中。在 `cleanup` 方法中，我们将学科和数组一起输出。

在 Reducer 中，我们首先对相同学科的所有成绩进行累加，并记录成绩的个数。然后计算平均值，将学科和平均值分别设置到 `Text` 和 `DoubleWritable` 对象中，并输出键值对。在计算平均值时，我们使用两层嵌套的 `for` 循环来遍历输入的值，其中外层循环遍历所有的数组，内层循环遍历数组中的所有成绩。

在主程序中，我们首先创建一个 `Scan` 对象，指定要读取的列族和列名。然后使用 `TableMapReduceUtil` 类的 `initTableMapperJob` 方法设置输入格式、Mapper 类、输出键值对类型等信息。最后设置 Reducer 类、输出键值对类型等信息，并提交作业。

需要注意的是，示例代码中数组的大小为 10，如果每个学科的成绩数量超过了 10，就会丢失一部分成绩。如果要处理数量不定的成绩，可以使用 `ArrayList` 等可变长数组来存储成绩。