Expert Java 8

Map<String, User> userById;
Map<String, Address> addrById;

Stream<User> users() {
	return userById.values().stream();
}

Stream<UserAddress> userAddresses() {
	return users()
		.map(user -> UserAddress.of(
				user, addrById.get(user.id())));
}

Map<Address, List<Order>> ordersByAddr;

Stream<Order> ordersFor(UserAdress userAddr) {
	return ordersByAddr
		.get(userAddr.address()).stream();
}

Stream<Delivery> deliveriesFor(UserAdress userAddr) {
	return ordersFor(userAddr)
		.map(order -> Delivery.of(userAddr, order));
}

Stream<Delivery> deliveries() {
	return userAddresses().flatMap(this::deliveriesFor);
}

// consuming the passed stream
void addUsers(Stream<User> users) {
	users.forEach(this.users::add)
}

// transforming the passed stream
Stream<UserAddress> userAddresses(Stream<User> users) {
	return users
		.map(user -> UserAddress.of(
				user, addrById.get(user.id())));
}

Stream<User> parse(Stream<String> strings) {
	// compile error:
	// "Unhandled exception ParseException"
	return strings.map(this::parse);
}

User parse(String userString) throws ParseException {
	// ...
}

Stream<User> parse(Stream<String> strings) {
	return strings
		.map(string -> { try {
				return parse(string);
			} catch (ParseException ex) {
				return null;
			}})
		.filter(Objects::nonNull);
}

Stream<User> parse(Stream<String> strings) {
	return strings
			.map(this::tryParse)
			.filter(Objects::nonNull);
}

private User tryParse(String string) {
	try { return parse(string); }
	catch (ParseException ex) { return null; }
}

static Function<T, R> hideException(
		CheckedFunction<T, R, Exception> function) {
	return element -> {
		try {
			return function.apply(element);
		} catch (Exception ex) {
			return sneakyThrow(ex);
		}
	};
}

// sneakyThrow does shenanigans with generics
// and unchecked casts to "confuse the compiler"

Stream<User> parse(Stream<String> strings) {
	return strings
		.map(Util.hideException(this::parse));
}

static Function<T, R> uncheckException(
		CheckedFunction<T, R, Exception> function) {
	return element -> {
		try {
			return function.apply(element);
		} catch (Exception ex) {
			// add special cases for RuntimeException,
			// InterruptedException, etc.
			throw new IllegalArgumentException(
				element, ex);
		}
	};
}

Stream<User> parse(Stream<String> strings) {
	return strings
		.map(Util.uncheckException(this::parse));
}

static Function<T, Optional<R>> wrapOptional(
		CheckedFunction<T, R, Exception> function) {
	return element -> {
		try {
			return Optional.of(
				function.apply(element));
		} catch (Exception ex) {
			return Optional.empty();
		}
	};
}

Stream<User> parse(Stream<String> strings) {
	return strings
		.map(Util.wrapOptional(this::parse))
		// Java 9: .flatMap(Optional::stream)
		.filter(Optional::isPresent)
		.map(Optional::get);
}

static Function<T, Try<R>> wrapTry(
		CheckedFunction<T, R, Exception> function) {
	return element -> Try.of(
		() -> function.apply(element));
}

Stream<Try<User>> parse(Stream<String> strings) {
	return strings
		.map(Util.wrapTry(this::parse));
}

static Function<T, Either<EX, R>> wrapEither(
		CheckedFunction<T, R, EX> function) {
	return element -> {
		try {
			return Either.right(
				function.apply(element));
		} catch (Exception ex) {
			// add special cases for RuntimeException,
			// InterruptedException, etc.
			return Either.left((EX) ex);
		}
	};
}

Stream<Either<ParseException, User>> parse(
		Stream<String> strings) {
	return strings
		.map(Util.wrapEither(this::parse));
}

Optional<User> findUser(String id) {
	return users.stream()
		.filter(user -> user.id().equals(id))
		.findFirst();
}

Optional<User> findUser(String id) {
	for (User user : users)
		if (user.id().equals(id))
			return Optional.of(user);
	return Optional.empty();
}

Optional<User> findUser(String id) {
	return users.stream()
		.filter(user -> user.id().equals(id))
		.reduce(toOnlyElement());
}

static BinaryOperator toOnlyElement() {
	return (element, otherElement) -> {
		throw new IllegalArgumentException();
	};
}

// takes 0.123
int m = Integer.MIN_VALUE;
for (int i = 0; i < intArray.length; i++)
	if (intArray[i] > m)
		m = intArray[i];

// takes 0.599
Arrays.stream(intArray).max();

Optional.ofNullable(mango)
	.ifPresent(System.out::println);

if (mango != null)
	System.out.println(mango);

String bar(Optional<String> drink) {
	return drink.map(this::bar)
			.orElseGet(this::bar);
}

String bar(String drink) { /* ... */ }

String bar() { /* ... */ }

ZonedDateTime getLastLogin(User user);
void storeMessage(ZonedDateTime time, String message);

String lastLoginMessage(User user) {
	ZonedDateTime lastLogin = getLastLogin(user); (1)
	String message = "Was " + lastLogin;
	storeMessage(lastLogin, message); (2)
	return message;
}

Objects.equals(
	ofNullable(x).flatMap(f),
	f.apply(x));

Function f = s -> of("mango")
Optional ofMap =
	ofNullable(null).flatMap(f);
Optional apply = f.apply(null);
// Optional[] != Optional["mango"]

Objects.equals(
	ofNullable(x).map(f).map(g),
	ofNullable(x).map(f.andThen(g)));

Function f = s -> null;
Function g = s -> "mango";
Optional map = of("kiwi").map(f).map(g);
Optional then = of("kiwi").map(f.andThen(g));
// Optional[] != Optional["mango"]

Component component = /*...*/;
Component decorated =
	new SomeDecorator(
		new AnotherDecorator(component));

Component component = /*...*/;
Component decorated = DecoratingComponent.from(component)
	.some() // applies `SomeDecorator`
	.another("param") // applies `AnotherDecorator`
	.decorate(YetAnotherDecorator::new);

interface DecoratingC extends Component {

	static DecoratingC from(Component component) {
		return new DecoratingComponent() {
			// implement by forwarding to component
		};
	}

	default DecoratingC decorate(
		Function<DecoratingC, DecoratingC> decorator) {
		return decorator.apply(this);
	}

}

Component component = /*...*/;
Component decorated = DecoratingComponent.from(component)
	.decorate(SomeDecorator::new);
	.decorate(c -> new AnotherDecorator(c, "param"));
	.decorate(YetAnotherDecorator::new);

interface DecoratingC extends Component {

	default DecoratingC some()
		return decorate(SomeDecorator::new);
	}

	default DecoratingC another(String s)
		return decorate(
			c -> new AnotherDecorator(c, s));
	}

}

HyperlinkListener listener =
	this::changeHtmlViewBackgroundColor;
listener = DecoratingHyperlinkListener.from(listener)
	.onHoverMakeVisible(urlLabel)
	.onHoverSetUrlOn(urlLabel)
	.logEvents()
	.decorate(l ->
		new OnActivateHighlightComponent(l, urlLabel))
	.decorate(OnEnterLogUrl::new);

interface DecoratingComponent extends Component {
	static DC from(Component component);
	default DC decorate(Function<DC, DC> decorator);
	default DC log(Level level);
}