Elevator system
Keep going while there's somewhere to go.

ElevatorController
  List<ElevatorCar> cars
  DispatchStrategy strategy
  onHallCall(floor, dir)
  onCarCall(carId, floor)
  tick()

ElevatorCar
  int floor
  Direction dir
  ElevatorState state
  TreeSet<Integer> upStops
  TreeSet<Integer> downStops
  addStop(int)
  step()

DispatchStrategy (interface)
  select(List<ElevatorCar>, HallCall): ElevatorCar

NearestCarStrategy

LeastLoadedStrategy

How they connect:
  NearestCarStrategy implements DispatchStrategy
  LeastLoadedStrategy implements DispatchStrategy
  ElevatorController uses DispatchStrategy
  ElevatorController owns ElevatorCar (1 to many)

enum Direction { UP, DOWN, NONE }
enum ElevatorState { IDLE, MOVING, DOORS_OPEN, MAINTENANCE }
record HallCall(int floor, Direction direction) {}

class ElevatorCar {
    final int id;
    private int floor = 0;
    private Direction direction = Direction.NONE;
    private ElevatorState state = ElevatorState.IDLE;
    private final TreeSet<Integer> upStops = new TreeSet<>();     // stops above, in ascending order
    private final TreeSet<Integer> downStops = new TreeSet<>();   // stops below

    ElevatorCar(int id) { this.id = id; }

    synchronized void addStop(int target) {
        if (state == ElevatorState.MAINTENANCE) throw new IllegalStateException("Car " + id + " in maintenance");
        if (target > floor) upStops.add(target);
        else if (target < floor) downStops.add(target);
        else { state = ElevatorState.DOORS_OPEN; return; }       // already here
        if (direction == Direction.NONE) direction = target > floor ? Direction.UP : Direction.DOWN;
    }

    /** One simulation tick: move a floor, or open the doors at a stop (LOOK algorithm). */
    synchronized void step() {
        if (state == ElevatorState.MAINTENANCE) return;
        if (state == ElevatorState.DOORS_OPEN) { state = upStops.isEmpty() && downStops.isEmpty() ? ElevatorState.IDLE : ElevatorState.MOVING; return; }

        if (direction == Direction.UP && upStops.isEmpty()) direction = downStops.isEmpty() ? Direction.NONE : Direction.DOWN;
        if (direction == Direction.DOWN && downStops.isEmpty()) direction = upStops.isEmpty() ? Direction.NONE : Direction.UP;
        if (direction == Direction.NONE) { state = ElevatorState.IDLE; return; }

        floor += (direction == Direction.UP) ? 1 : -1;
        state = ElevatorState.MOVING;
        if (direction == Direction.UP && upStops.remove(floor)) state = ElevatorState.DOORS_OPEN;
        if (direction == Direction.DOWN && downStops.remove(floor)) state = ElevatorState.DOORS_OPEN;
    }

    synchronized int floor() { return floor; }
    synchronized Direction direction() { return direction; }
    synchronized ElevatorState state() { return state; }
    synchronized int pendingStops() { return upStops.size() + downStops.size(); }
}

interface DispatchStrategy { ElevatorCar select(List<ElevatorCar> cars, HallCall call); }

/** Prefer an idle car or one already heading toward the floor in the same direction; else the nearest. */
class NearestCarStrategy implements DispatchStrategy {
    private final int totalFloors;
    NearestCarStrategy(int totalFloors) { this.totalFloors = totalFloors; }

    public ElevatorCar select(List<ElevatorCar> cars, HallCall call) {
        return cars.stream()
            .filter(c -> c.state() != ElevatorState.MAINTENANCE)
            .min(Comparator.comparingInt(c -> cost(c, call)))
            .orElseThrow(() -> new IllegalStateException("No elevator available"));
    }
    private int cost(ElevatorCar c, HallCall call) {
        int distance = Math.abs(c.floor() - call.floor());
        boolean onTheWay = (c.direction() == Direction.UP && call.direction() == Direction.UP && c.floor() <= call.floor())
                        || (c.direction() == Direction.DOWN && call.direction() == Direction.DOWN && c.floor() >= call.floor());
        if (c.direction() == Direction.NONE || onTheWay) return distance;
        return distance + 2 * totalFloors;                       // heading away: it must finish its sweep first
    }
}

class ElevatorController {
    private final List<ElevatorCar> cars; private final DispatchStrategy strategy;
    ElevatorController(List<ElevatorCar> cars, DispatchStrategy strategy) { this.cars = cars; this.strategy = strategy; }

    public void onHallCall(int floor, Direction dir) { strategy.select(cars, new HallCall(floor, dir)).addStop(floor); }
    public void onCarCall(int carId, int floor)     { cars.get(carId).addStop(floor); }
    public void tick()                              { cars.forEach(ElevatorCar::step); }   // driven by a scheduler every ~1s
}