Looping within multiple arrays in Java Stream

Question

I would need some help optimising the way to iterate through a list of 200 lines. My 1st class is as below

Class Vehicle
 Date date
 int nbOfVehicleArriving


Class Planning
 int date
 int nbOfallowedVehicles

So, I have a list of Vehicles arriving per time ex:

01/01/2018 00:00:00 12
01/01/2018 00:10:00 10
01/01/2018 01:00:00 5
01/01/2018 01:10:00 10
....

And I have some agenda

01/01/2018 00:00:00 3
01/01/2018 00:10:00 2
01/01/2018 01:00:00 3
01/01/2018 01:10:00 5

I need to calculate the number of vehicles in the queue.

What i'm planning to do is to iterate with the Vehicles and then in it iterate with the Planning.

Is there a better way of doing this??

Thanks in advance

Answer 1

You may try this out.

Map<Date, Integer> agendasByDate = agendas.stream()
        .collect(Collectors.toMap(Planning::getDate, Planning::getNbOfallowedVehicles));

Map<Date, Integer> vehiclesInQueueByDate = vehicles.stream().collect(Collectors.toMap(Vehicle::getDate,
        v -> v.getNbOfVehicleArriving() - agendasByDate.get(v.getDate())));

Answer 2

You could also use flatMap to merge the two arrays together and then simply extract the counts (this would involve casting) and sum these up.

Here is a full working example demonstrating how you can use flatMap:

import java.util.Arrays;
import java.util.Date;
import java.util.stream.Stream;

public class MergeStreams {

    public static void main(String[] args) {
        Vehicle[] vehicles = {new Vehicle(new Date(), 10), new Vehicle(new Date(), 11)};
        Planning[] plannings = {new Planning(new Date(), 5), new Planning(new Date(), 12)};
        int sum = Stream.of(vehicles, plannings)
            .flatMap(Arrays::stream)
            .map(object -> object instanceof Vehicle ? ((Vehicle) object).getNbOfVehicleArriving() : ((Planning) object).getNbOfallowedVehicles())
            .mapToInt(Integer::intValue)
            .sum();
        System.out.println(sum);
    }
}

class Vehicle {
    private Date date;
    private int nbOfVehicleArriving;

    public Vehicle(Date date, int nbOfVehicleArriving) {
        this.date = date;
        this.nbOfVehicleArriving = nbOfVehicleArriving;
    }

    public int getNbOfVehicleArriving() {
        return nbOfVehicleArriving;
    }
}


class Planning {
    private Date date;
    private int nbOfallowedVehicles;

    public Planning(Date date, int nbOfallowedVehicles) {
        this.date = date;
        this.nbOfallowedVehicles = nbOfallowedVehicles;
    }

    public int getNbOfallowedVehicles() {
        return nbOfallowedVehicles;
    }
}

If you run this example it will output 38 on the console.

Answer 3

For 200 lines it probably doesn't make any difference what solution you choose. But if you want a solution which scales to a very long list the correct approach is to zip the two lists (or streams) together (this way you avoid looping twice), and use a function to produce the combined result. Guava itself provides a zip() method, but you can also write your own.

Not sure what you mean by 'number of vehicles in the queue', but I am going to assume that you want to know how many were left in the end that have not been allowed in yet.

You can create your own class which maps the vehicles arriving with the agenda for that date.

public class VehiclePlanningData {

    private final Vehicle vehicle;
    private final Planning planning;

    public  VehiclePlanningData(Vehicle vehicle, Planning planning) {
        this.vehicle = vehicle;
        this.planning = planning;
    }

    public Vehicle getVehicle() {
        return vehicle;
    }

    public Planning getPlanning() {
        return planning;
    }
}

Once you have this you can easily do a reduce() operation to carry forward any vehicles left over from the previous slot.

So something like this (using the Guava Streams class):

int queue = Streams.zip(vehicles.stream(), planning.stream(), (v, p) -> new VehiclePlanningData(v, p))
           .reduce(0, (queue, nextSlot) -> 
              queue + (nextSlot.getVehicle().getNbOfVehicleArriving() 
                       - nextSlot.getPlanning().getNbOfallowedVehicles(), 
              (q1, q2) -> q1 + q2);

UPDATE:

Seems that the queue is per time slot. In that case you might want to have a special class like this, which stores the queue size per slot:

public class TimeslotQueue {
   private final Date date;
   private final int queueSize;

   public VehicleQueue(Date date, int queueSize) {
     this.date = date;
     this.queueSize = queueSize;
   }

   public Date getDate() { 
     return date;
   }

   public int getQueueSize() {
     return queueSize;
   }
 }

Then get a stream of these classes like this:

    List<TimeslotQueue> queues = Streams.zip(vehicles.stream(), planning.stream(), 
         (v, p) -> new TimeslotQueue(v.getDate(), 
                        v.getNbOfVehicleArriving() - p.getNbOfallowedVehicles()))
         .collect(Collectors.toList());

This way you have a list of queued vehicles for each date. As a side note, I would use the Java 8 LocalDateTime not the old Date class.