如何提高Java中用于语句的低效率重复项

Question

I am using a duplicate for statement for some reason, but somehow I feel inefficient. The reasons why I use duplicated for statement is below.

• I got 'channel' data, which is a List of Channel information
• Channel Information is ' Map<String, Object> ' type which has many elements
• There is another list of Map<String, Object> which represent program information
• What I need to do in insert a program in to each channels

Source code is below

public static void injectProgram2Channel (
            List<Map<String, Object>> channelList, List<Map<String, Object>> programList) throws Exception {
        for(Map<String, Object> channel : channelList){
            String serviceId = channel.get("serviceId").toString();
            ArrayList<Map<String, Object>> programsForChannel = new ArrayList<Map<String,Object>>();
            for(Map<String, Object> program : programList){
                if(serviceId.equals(program.get("serviceId").toString())){
                    programsForChannel.add(program);
                }
            }
            channel.put("programs", programsForChannel);
        }
    }

I do not want to iterate all of this List, since each List has many elements. How can I improve its performance?

• Channel List has around 500 Elements
• Program List has around 2000 Elements

(I need solution which does not using duplicated for statement)

Answer 1

You need to ask yourself the question: does it matter how fast it is. If it doesn't, don't make code more complex. "Premature optimization is the root of all evil".

Once you have confirmed that performance is relevant, try to create a benchmark eg using JMH and with that in place, start to optimise.

Answer 2

Channel List has around 500 Elements
Program List has around 2000 Elements

Those are really small in real world applications. You shouldn't worry if you have only two nested for loops for that amount of data.

Answer 3

As hinted a possible option that may or may not make sense in your case would be to just group the programs by serviceId into a new Map<String, List<Map<String, Object>>> and lookup the programs when needed.

public static Map<String, List<Map<String, Object>>> buildProgramList (
        List<Map<String, Object>> programList) throws Exception {

    Map<String, List<Map<String, Object>>> programsByServiceId = new HashMap<>();

    for(Map<String, Object> program : programList){
        String serviceId = program.get("serviceId").toString();
        if(programsByServiceId.containsKey(serviceId)){
            programsByServiceId.get(serviceId).add(program);
        } else {
            programsByServiceId.put(serviceId,
                    new ArrayList<Map<String, Object>>(){{
                add(program);
            }});
        }
    }
    return programsByServiceId;
}

Once this structures is built, just retrieve your programs for a channel by calling

List<Map<String, Object>> programs = programsByServiceId.get(channel.get("serviceId").toString());

And if you want to get extra fancy you could lazy load the results in to the channel . Something like

if (channel.get("programs") == null) 
    channel.put("programs", programsByServiceId.get(channel.get("serviceId").toString());
return channel.get("programs");

This would defer the upfront cost and spread it out.

When this might make sense. If there are certain channels that are looked up more often than others for their program list.

When this does not make sense. All of the channels are requested their list of programs immediately or soon after. (like if you are just going to serialize all of the channels and their programs).