public final class CollectorUtils {
    private CollectorUtils() {
        throw new UnsupportedOperationException();
    }

    public static <E, R, X extends RuntimeException> Collector<E, ?, R> listAndThenCollector(final Predicate<List<E>> listPredicate, final Function<List<E>, R> listFunction, final Supplier<X> exceptionSupplier) {
        Objects.requireNonNull(listPredicate);
        Objects.requireNonNull(listFunction);
        Objects.requireNonNull(exceptionSupplier);
        return Collectors.collectingAndThen(Collectors.toList(), list -> {

    @Override
    public void executeEvent(final Object event) {
        if (eventClassConstraint.isAssignableFrom(event.getClass())) {
            Arrays.stream((EventHandler[])eventMapping.getOrDefault(event.getClass(), EMPTY_SET).toArray())
                    .forEach(eventHandler -> eventHandler.invoke(event));
        }
    }

synchronized (existing) {
    existing.add(handler);
}

@Override
public void executeEvent(final Object event) {
    if (eventClassConstraint.isAssignableFrom(event.getClass())) {
        Set<EventHandler> eventHandlerSet = eventMapping.getOrDefault(event.getClass(), EMPTY_SET);
        EventHandler[] eventHandlerArray = eventHandlerSet.toArray(new EventHandler[eventHandlerSet.size()]);
        Arrays.stream(eventHandlerArray).forEach(eventHandler -> eventHandler.invoke(event));
    }
}

@Override
public void executeEvent(final Object event) {
    if (classConstraint.isAssignableFrom(event.getClass())) {
        Arrays.stream(getEventHandlers(event.getClass())).forEach(eventHandler -> eventHandler.invoke(event));
    }
}

@Override
public void executeEvent(final Object event) {
    if (eventClassConstraint.isAssignableFrom(event.getClass())) {
        Set<EventHandler> eventHandlerSet = eventMapping.getOrDefault(event.getClass(), Collections.synchronizedSet(EMPTY_SET));
        EventHandler[] eventHandlerArray = eventHandlerSet.toArray(new EventHandler[eventHandlerSet.size()]);
        Arrays.stream(eventHandlerArray).forEach(eventHandler -> eventHandler.invoke(event));
    }
}

    private Stream<EventHandler> getEventHandlers(final Class<?> eventClass) {
        Set<EventHandler> eventHandlers = eventMapping.get(Objects.requireNonNull(eventClass));
        if (eventHandlers == null) {
            return Stream.empty();
        }
        return Arrays.stream(eventHandlers.toArray(new EventHandler[eventHandlers.size()]));
    }

    @Override
    public void executeEvent(final Object event) {
        if (eventClassConstraint.isAssignableFrom(event.getClass())) {
            getEventHandlers(event.getClass()).forEach(eventHandler -> eventHandler.invoke(event));

 eventHandlers.toArray(new EventHandler[eventHandlers.size()])

eventHandlers.size()

synchronized(handlers) {
    return handlers.toArray(new EventHandler[handlers.size()]);
}

private Stream<EventHandler> getEventHandlers(final Class<?> eventClass) {
    Set<EventHandler> eventHandlers = eventMapping.get(Objects.requireNonNull(eventClass));
    return (eventHandlers == null)
            ? Stream.empty()
            : Arrays.stream(eventHandlers.toArray(new EventHandler[0]));
}

T[] r = a.length >= size ? a :
          (T[])java.lang.reflect.Array
          .newInstance(a.getClass().getComponentType(), size);