Java: Most efficient way to map properties of one list of objects to another

Question

I'm looking for an efficient design pattern to map one list of objects to another list of objects with zero-or-one-to-one relationships between them. I realize this sort of thing is typically done in a relational database, but in this particular case it really needs to be done in the Java application...

Let's say the first list contains Foo objects (i.e. List<Foo>):

public class Foo {
    public Integer id;
    public String barName;
}

And the second list contains Bar objects (i.e. List<Bar>):

public class Bar {
    public Integer fooId;
    public String name;
}

How can I most efficiently map all name properties from Bar to the Foo object where Bar.fooId equals Foo.id?

The best I can think of is this:

void mapFooBar(List<Foo> fooList, List<Bar> barList) {
    for (Bar bar : barList) {
        for (Foo foo : fooList) {
            if (bar.fooId.equals(foo.id)) foo.barName = bar.name;
        }
    }
}

EDIT: Based on several answers, I have improved my code as follows:

void mapFooBar(List<Foo> fooList, List<Bar> barList) {
    Map<Integer, String> barMap = new HashMap<Integer, String>();
    for (Bar bar : barList)
        barMap.put(bar.fooId, bar.name);

    for (Foo foo : fooList)
        if (barMap.containsKey(foo.id)) foo.barName = barMap.get(foo.id);
}

Is there a better way?

Better use solutions from here: stackoverflow.com/questions/6796187/…. — Gangnus
– Gangnus, Commented Feb 24, 2020 at 13:38

mdatwood · Accepted Answer · 2014-03-01 01:03:14Z

2

I think what you are looking for is something like Apache BeanUtils or Springs implementation. Just make sure the properties are named the same between the 2 objects you want to copy the data between. So taking your code:

void mapFooBar(List<Foo> fooList, List<Bar> barList) {
  for (Bar bar : barList) {
    for (Foo foo : fooList) {
        if (bar.fooId.equals(foo.id)) {
            BeanUtils.copyProperties(foo, bar);
        }
    }
  }
}

Now that the copy is done lets look at your loop. Your best bet would be to keep the Objects in Maps using fooId as the key (assuming no objects duplicated).

void mapFooBar(Map<Integer, Foo> fooMap, Map<Integer, Bar> barMap) {
  for (Integer key : fooMap.keySet()) {
    if (barMap.containsKey(key) {
      Bar bar = barMap.get(key);
      Foo foo = fooMap.get(key);
      BeanUtils.copyProperties(foo, bar);
    }
  }
}

answered Mar 1, 2014 at 1:03

mdatwood

981 silver badge5 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Shaun Scovil Over a year ago

Thanks for your response! I agree with your suggestion for improving the loop using a map, as others have suggested, but I don't see the benefit of using BeanUtils.copyProperties(foo, bar) since I only need to map a single property.

mdatwood Over a year ago

Gotcha, I thought you only put in a single property as an example. Leave out the BeanProperties then.

Jigar Joshi · Accepted Answer · 2014-03-01 00:57:26Z

1

This has complexity of N * M that means if you have 5 foo and 8 bar it would have to execute loop for 40 times

class Container{

  List<Foo> foos;
  List<Bar> bars;

}

if you use Map<Integer, Container> it would be N + M (5 + 8 = 13 times)

iterate through both list once and map it with id

Also See

java 8 parallel stream, filter

edited Mar 1, 2014 at 0:57

answered Mar 1, 2014 at 0:33

Jigar Joshi

241k42 gold badges409 silver badges446 bronze badges

1 Comment

Shaun Scovil Over a year ago

Thank you for your response. I don't quite follow...could you illustrate how this would be used to map values from bars to foos?

Sidi · Accepted Answer · 2014-03-02 18:01:30Z

1

Take a look at Orika, an efficient Java Object to Object Mapping

https://github.com/orika-mapper/orika

answered Mar 2, 2014 at 18:01

Sidi

1,75914 silver badges16 bronze badges

Comments

DTHENG · Accepted Answer · 2015-04-23 23:39:50Z

1

In Java 1.8 you can write it like this:

void mapFooBar(List<Foo> fooList, List<Bar> barList) {

    Map<Integer, String> barMap = new HashMap<Integer, String>();

    barList.stream()
        .forEach(bar -> barMap.put(bar.fooId, bar.name));

    fooList.stream()

        // replaces if statement
        .filter(foo -> barMap.containsKey(foo.id))

        // update the bar name
        .forEach(foo -> {
            foo.barName = barMap.get(foo.id);
        });
}

answered Apr 23, 2015 at 23:39

DTHENG

1881 silver badge7 bronze badges

Comments

Robert Moskal · Accepted Answer · 2015-06-11 03:22:55Z

1

Hmm. Assuming the "primary keys" were unique I might convert the list of Bar to a map with fooId as the key and either whole object or the name as the value. Then I would iterate through the list of Foo and see whether the id property existed in the map. If it did I would map the bar.name to foo.barName;

edited Jun 11, 2015 at 3:22

answered Mar 1, 2014 at 0:35

Robert Moskal

22.7k8 gold badges69 silver badges91 bronze badges

1 Comment

Shaun Scovil Over a year ago

Thanks for the response! Based on your answer and @Jigar's answer, I see that looping through List<Bar> once to create a map, then looping through List<Foo> once to check against the map keys, is more efficient than doing the nested loop. And yes, my ids are unique.

goten · Accepted Answer · 2014-03-01 00:58:09Z

0

You could use a HashMap to store all Foo objects, with their id as key.

Then loop through Bar list and access directly HashMap position you want

answered Mar 1, 2014 at 0:58

goten

9909 silver badges9 bronze badges

1 Comment

Nitin Nanda Over a year ago

What type of HashMap because I have attributes of type String, Integer and sql.Date

Collectives™ on Stack Overflow

Java: Most efficient way to map properties of one list of objects to another

6 Answers 6

2 Comments

1 Comment

Comments

Comments

1 Comment

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

2 Comments

1 Comment

Comments

Comments

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related