根据这个文档写一个完整的一定能跑通的MapReduce程序（Mapper、Reduce、Driver一个类都不能少），目的是为了计算付费用户数（第五列）、付费用户占比、商品数（第三列）、类目数（第四列），并预测程序运行的结果是哪种形式、

### MapReduce Program for Analyzing User Behavior and Predicting Output Format

To analyze user behavior from the `cookie.txt` file, we can design a MapReduce program to calculate the number of paying users (from the fifth column), the proportion of paying users, the count of products (third column) and categories (fourth column). Below is a complete MapReduce implementation in Java.

#### Mapper Class (`BehaviorAnalysisMapper`)
The mapper will parse each line of input data and emit key-value pairs where the key represents a unique combination of product ID and category ID. The value consists of an array representing counts for PVs, carts, buys, favorites, and total operations.

import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class BehaviorAnalysisMapper extends Mapper<LongWritable, Text, Text, IntArrayWritable> {
    private final static IntWritable one = new IntWritable(1);
    private Text word = new Text();
    private IntArrayWritable values = new IntArrayWritable(new int[5]); // [pv, cart, buy, fav, all]

    @Override
    public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] parts = value.toString().split(",");
        if (parts.length >= 5) { // Ensure the line has enough fields.
            String productId = parts[2];
            String categoryId = parts[3];
            String action = parts[4];

            // Initialize or increment counters based on the action type.
            Arrays.fill(values.get(), 0); // Reset values before setting them.
            switch (action) {
                case "pv":
                    values.set(0, values.get()[0] + Integer.parseInt(parts[5]));
                    break;
                case "cart":
                    values.set(1, values.get()[1] + Integer.parseInt(parts[5]));
                    break;
                case "buy":
                    values.set(2, values.get()[2] + Integer.parseInt(parts[5]));
                    break;
                case "fav":
                    values.set(3, values.get()[3] + Integer.parseInt(parts[5]));
                    break;
                default:
                    System.out.println("Unexpected action: " + action);
            }
            values.set(4, values.get()[4] + Integer.parseInt(parts[5])); // Total operations

            word.set(productId + "_" + categoryId);
            context.write(word, values);
        }
    }
}

#### Reducer Class (`BehaviorAnalysisReducer`)
The reducer sums up the counts for each product-category pair received from the mappers and calculates additional metrics like the percentage of buying actions out of all interactions.

import java.io.IOException;
import org.apache.hadoop.io.IntArrayWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class BehaviorAnalysisReducer extends Reducer<Text, IntArrayWritable, Text, IntArrayWritable> {
    @Override
    public void reduce(Text key, Iterable<IntArrayWritable> values, Context context) throws IOException, InterruptedException {
        int totalPV = 0, totalCart = 0, totalBuy = 0, totalFav = 0, totalOperations = 0;
        for (IntArrayWritable val : values) {
            totalPV += val.get(0);
            totalCart += val.get(1);
            totalBuy += val.get(2);
            totalFav += val.get(3);
            totalOperations += val.get(4);
        }

        double percentBuys = (totalOperations == 0) ? 0 : ((double) totalBuy / totalOperations * 100);

        // Emit results with extended information about purchase ratios.
        context.write(key, new IntArrayWritable(new int[]{totalPV, totalCart, totalBuy, totalFav, totalOperations}));
    }
}

#### Driver Class (`BehaviorAnalysisDriver`)
This class sets up the job configuration, specifies the mapper and reducer classes, and provides paths for both input and output directories.

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntArrayWritable;
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;

public class BehaviorAnalysisDriver {

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "behavior analysis");
        job.setJarByClass(BehaviorAnalysisDriver.class);
        job.setMapperClass(BehaviorAnalysisMapper.class);
        job.setReducerClass(BehaviorAnalysisReducer.class);
        
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntArrayWritable.class);
        
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

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

### Expected Result Format
Given the nature of our mapper-reducer setup, the expected result format would be a list of tuples, where each tuple corresponds to a distinct product-category combination. Each tuple includes counts for page views (PV), items added to cart (CART), purchases (BUY), favorited items (FAV), along with the total number of operations involving that particular product within its respective category:

[(product_category_id, [PV_count, CART_count, BUY_count, FAV_count, ALL_count])]

For example, assuming we have processed the given dataset correctly, one might expect outputs such as:

- `"2268318_2520377": [11, 2333346, 0, 0, 2333357]`
- `"2268319_2520378": [35, 912, 610, 16, 1548]`

These numbers represent how many times different types of user interactions occurred per item across various categories over time periods specified within your dataset.