Most efficient way to find the collection of all ids in a collection of entities
You won't get anything shorter than:
Collection<Long> ids = new ArrayList<>();
for (Entity e : entities) ids.add(e.getId());
I assume all ways would iterate over the collection
Not necessarily. This creates a collection that is directly backed by the underlying entities collection (future changes to the entities collection appear in the ids collection):
Collection<Long> ids = new AbstractCollection<Long>() {
@Override
public int size() {
return entities.size();
}
@Override
public Iterator<Long> iterator() {
return new Iterator<Long>() {
private Iterator<Entity> base = entities.iterator();
@Override public boolean hasNext() { return base.hasNext(); }
@Override public Long next() { return base.next().getId(); }
@Override public void remove() { base.remove(); }
};
}
};
Most efficient? Basically just iterate and add to the list. You have to look at each item.
Collection<Long> ids = new LinkedList<Long>();
for (Entity e : entities) {
ids.add(e.id);
}
Or, if you can use Java 1.8, you can do something like:
entities.forEach((e) -> ids.add(e.id));
Assuming you have
class Entity {
final long id;
final String data;
public long getId() {
return id;
}
public String getData() {
return data;
}
Entity(long id, String data) {
this.id = id;
this.data = data;
}
}
In Java 8 you can write
Collection<Entity> entities = Arrays.asList(new Entity(1, "one"),
new Entity(11, "eleven"), new Entity(100, "one hundred"));
// get a collection of all the ids.
List<Long> ids = entities.stream()
.map(Entity::getId).collect(Collectors.toList());
System.out.println(ids);
prints
[1, 10, 100]
As you can imagine this is rather ugly in Java 7 or less. Note the Entity.getId
when applied to map() means call this method on each element.
Now, the real interesting part is you can do this.
List<Long> ids = entities.parallelStream()
.map(Entity::getId).collect(Collectors.toList());
In most cases using a parallel stream will hurt performance, but it makes trying it and seeing amazingly easy (possibly too easy ;)
The most efficient way is to have, or build a Map.
Map<Long, Entity> entitiesMap = ...
// get all ids
Collection<Long> addIds = entitiesMap.keySet();
// look up entities by id.
List<Long> ids = ...
List<Entity> matching = new ArrayList<>();
for(Long id: ids)
matching.add(entitiesMap.get(id));