Commons functional

A collection of Functional helpers

Tuples

From 1 to 10 fields

import es.rubenjgarcia.commons.functional.tuple.*;
import static es.rubenjgarcia.commons.functional.tuple.Tuple.tuple;

Tuple2 t2 = tuple("1", "2");
t2.toString(); // (1, 2)
t2.equals(tuple("1", "2")); // true

Stream Utils

zip

Returns a list of Tuple2 formed from two streams by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.

import static es.rubenjgarcia.commons.functional.StreamUtils.zip;

List<Integer> ints = Arrays.asList(1, 2, 3);
List<String> strings = Arrays.asList("a", "b", "c");

List<Tuple2<Integer, String>> tuples = zip(ints.stream(), strings.stream()).collect(Collectors.toList());
tuples.toString(); // [(1, a), (2, b), (3, c)]

zipWithIndex

import static es.rubenjgarcia.commons.functional.StreamUtils.zipWithIndex;

List<String> strings = Arrays.asList("1", "2", "3");
List<Tuple2<Long, String>> tuples = zipWithIndex(strings.stream()).collect(Collectors.toList());

unzip

Converts a collection of Tuple2 into a Tuple2 of stream of the first and second half of each pair

import es.rubenjgarcia.commons.functional.tuple.*;
import static es.rubenjgarcia.commons.functional.StreamUtils.unzip;

Tuple2<Stream<Integer>, Stream<String>> tupleStream = unzip(tuples);
List<Integer> ints = tupleStream._1.collect(Collectors.toList());
List<String> strings = tupleStream._2.collect(Collectors.toList());

Functional Filters

anyOf

Return if the value matches any predicate

import static es.rubenjgarcia.commons.functional.FunctionalFilters.anyOf;

Predicate<Integer> p = anyOf(n -> n == 1, n -> n == 2);
p.test(1); // true
p.test(3); // false

noneOf

Return if the value doesn't match any of the predicates

import static es.rubenjgarcia.commons.functional.FunctionalFilters.noneOf;

Predicate<Integer> p = noneOf(n -> n == 1, n -> n == 2);
p.test(1); // false
p.test(3); // true

allOf

Return if the value matches all the predicates

import static es.rubenjgarcia.commons.functional.FunctionalFilters.allOf;

Predicate<Integer> p = allOf(n -> n > 1, n -> n < 3);
p.test(1); // false
p.test(2); // true

findFirst

Find the first element that matchs the predicate

import static es.rubenjgarcia.commons.functional.FunctionalFilters.findFirst;

Optional<Integer> found = findFirst(Stream.of(1, 2), n -> n == 1);
found.isPresent(); // true
found.get(); 1

findLast

Finds the last element that matchs the predicate

import static es.rubenjgarcia.commons.functional.FunctionalFilters.findLast;

Optional<Integer> last = findLast(Stream.of(1, 2, 3), p -> p > 1 && p <= 2);
last.isPresent(); // true
last.get(); // 2

findFirstNotMatch

Finds first element that doesn't match the predicate

import static es.rubenjgarcia.commons.functional.FunctionalFilters.findFirstNotMatch;

Optional<Integer> found = findFirstNotMatch(Stream.of(1, 2), n -> n == 1);
found.isPresent(); // true
found.get(); // 2

FlowStream

mapIf

Apply a map function to the element of a stream if the element matches the predicate

import static es.rubenjgarcia.commons.functional.FlowStream.mapIf;

List<Integer> list = Arrays.asList(1, 1, 1, 1);
List<Object> result = mapIf(list::stream, i -> i == 1, i -> "A")
        .collect(Collectors.toList()); // [A, A, A, A]

List<Integer> list = Arrays.asList(1, 2, 2, 1);
List<Object> result = mapIf(list::stream, i -> i == 1, i -> "A")
        .collect(Collectors.toList()); // [A, 2, 2, A]

elseIfMap

Apply a map function to the element of a stream if the element matches the predicate after a mapIf code

import static es.rubenjgarcia.commons.functional.FlowStream.mapIf;

List<Integer> list = Arrays.asList(1, 2, 3, 1);
List<Object> result = mapIf(list::stream, i -> i == 1, i -> "A")
        .elseIfMap(i -> i == 2, i -> "B")
        .collect(Collectors.toList()); // [A, B, 3, A]

import static es.rubenjgarcia.commons.functional.FlowStream.mapIf;

List<Integer> list = Arrays.asList(1, 2, 3, 1);
List<Object> result = mapIf(list::stream, i -> i == 1, i -> "A")
        .elseIfMap(i -> i == 2, i -> "B")
        .elseIfMap(i -> i == 3, i -> "C")
        .collect(Collectors.toList()); // [A, B, C, A]

elseMap

Apply a map function to the elements of a stream that don't match any of the other if or elseif predicates

import static es.rubenjgarcia.commons.functional.FlowStream.mapIf;

List<Integer> list = Arrays.asList(1, 2, 3, 1);
List<Object> result = mapIf(list::stream, i -> i == 1, i -> "A")
        .elseIfMap(i -> i == 2, i -> "B")
        .elseMap(i -> "C")
        .collect(Collectors.toList()); // [A, B, C, A]

import static es.rubenjgarcia.commons.functional.FlowStream.mapIf;

List<Integer> list = Arrays.asList(1, 2, 3, 1);
List<Object> result = mapIf(list::stream, i -> i == 1, i -> "A")
        .elseMap(i -> "C")
        .collect(Collectors.toList()); // [A, C, C, A]

mapIfAny

Apply a map function to all the elements of the stream if any of them match the predicate

import static es.rubenjgarcia.commons.functional.FlowStream.mapIfAny;

List<Integer> list = Arrays.asList(1, 2, 2, 1);
List<Object> result = mapIfAny(list::stream, i -> i == 1, i -> "A")
        .collect(Collectors.toList()); // [A, A, A, A]

elseIfAnyMap

Apply a map function to all the elements of the stream if any of them match the predicate and don't match the other predicates

import static es.rubenjgarcia.commons.functional.FlowStream.mapIfAny;

List<Integer> list = Arrays.asList(1, 1, 1, 1);
List<Object> result = mapIfAny(list::stream, i -> i == 2, i -> "A")
        .elseIfAnyMap(i -> i == 1, i -> "B")
        .collect(Collectors.toList()); // [B, B, B, B]

import static es.rubenjgarcia.commons.functional.FlowStream.mapIfAny;

List<Integer> list = Arrays.asList(1, 2, 3, 1);
List<Object> result = mapIfAny(list::stream, i -> i == 2, i -> "A")
        .elseIfAnyMap(i -> i == 4, i -> "B")
        .elseIfAnyMap(i -> i == 1, i -> "C")
        .collect(Collectors.toList()); // [C, C, C, C]

You can combine any of the flows

import static es.rubenjgarcia.commons.functional.FlowStream.mapIf;

List<Integer> list = Arrays.asList(1, 2, 1, 1);
List<Object> result = mapIf(list::stream, i -> i == 2, i -> "A")
        .elseIfAnyMap(i -> i == 1, i -> "B")
        .elseMap(i -> "C")
        .collect(Collectors.toList()); // [B, A, B, B]

Exceptions

You can use rethrowFunction, rethrowBiFunction, rethrowConsumer, rethrowBiConsumer, rethrowPredicate, rethrowBiPredicate or rethrowSupplier to deal with Function, BiFunction, Consumer, BiConsumer, Predicate, BiPredicate or Supplier that throws any checked Exception

import static es.rubenjgarcia.commons.functional.FunctionalExceptions.rethrowFunction;

Stream.of("a", "b").map(rethrowFunction(s -> new String(s.getBytes(), "Foo")));

import static es.rubenjgarcia.commons.functional.FunctionalExceptions.rethrowBiFunction;

Map<String, String> map = new HashMap<>();
map.put("a", "b");
map.replaceAll(rethrowBiFunction((k, v) -> new String(k.getBytes(), "Foo")))

import static es.rubenjgarcia.commons.functional.FunctionalExceptions.rethrowConsumer;

Stream.of("a", "b").forEach(rethrowConsumer(s -> new String(s.getBytes(), "Foo")));

import static es.rubenjgarcia.commons.functional.FunctionalExceptions.rethrowBiConsumer;

Map<String, String> map = new HashMap<>();
map.put("a", "b");
map.forEach(rethrowBiConsumer((k, v) -> new String(k.getBytes(), "Foo")));

import static es.rubenjgarcia.commons.functional.FunctionalExceptions.rethrowPredicate;

Stream.of("a", "b").filter(rethrowPredicate(s -> new String(s.getBytes(), "Foo") == null));

import static es.rubenjgarcia.commons.functional.FunctionalExceptions.rethrowBiPredicate;

BiPredicate<String, String> predicate = rethrowBiPredicate((s, e) -> new String(s.getBytes(), e).isEmpty());
predicate.test("a", "Foo");

import static es.rubenjgarcia.commons.functional.FunctionalExceptions.rethrowSupplier;

rethrowPredicate(() -> new String(s.getBytes(), "Foo"));

Installation

Just add to your pom.xml

<dependency>
    <groupId>es.rubenjgarcia</groupId>
    <artifactId>commons-functional</artifactId>
    <version>0.2.0</version>
</dependency>