什么是LINQ Join的Java 8 Stream API等价物？

Question

In C#/.Net it is possible to join IEnumerable sequences with the extension method Enumerable.Join in a SQL 'JOIN ... ON' way.

Is there something similar in Java 8 (Stream API)? Or what is the best way to simulate Enumerable.Join?

See: https://msdn.microsoft.com/en-us/library/bb534675%28v=vs.100%29.aspx

Answer 1

join is just syntactic sugar for Stream.flatMap() as explained in this article . Consider this example:

List<Integer> l1 = Arrays.asList(1, 2, 3, 4);
List<Integer> l2 = Arrays.asList(2, 2, 4, 7);

l1.stream()
  .flatMap(i1 -> l2.stream()
                   .filter(i2 -> i1.equals(i2)))
  .forEach(System.out::println);

The result is:

2
2
4

In the above example, flatMap() corresponds to (INNER) JOIN whereas the filter() operation of the nested stream corresponds to the ON clause.

jOOλ is a library that implements innerJoin() and other join types to abstract over this, eg also to buffer stream contents in case you want to join two Stream instances, instead of two Collection instances. With jOOλ, you would then write:

Seq<Integer> s1 = Seq.of(1, 2, 3, 4);
Seq<Integer> s2 = Seq.of(2, 2, 4, 7);

s1.innerJoin(s2, (i1, i2) -> i1.equals(i2))
  .forEach(System.out::println);

... which prints (the output are tuples, which is more like SQL's semantics semantics):

(2, 2)
(2, 2)
(4, 4)

(disclaimer, I work for the company behind jOOλ)

Answer 2

I haven't found any existing equivalent, but the below method should work:

public static <Outer, Inner, Key, Result> Stream<Result> join(
        Stream<Outer> outer, Stream<Inner> inner,
        Function<Outer, Key> outerKeyFunc,
        Function<Inner, Key> innerKeyFunc,
        BiFunction<Outer, Inner, Result> resultFunc) {

    //Collect the Inner values into a list as we'll need them repeatedly
    List<Inner> innerList = inner.collect(Collectors.toList());

    //matches will store the matches between inner and outer
    final Map<Outer, List<Inner>> matches = new HashMap<>();

    //results will be used to collect the results in
    final List<Result> results = new ArrayList<>();


    outer.forEach(o -> innerList
            .stream()
            //Filter to get those Inners for which the Key equals the Key of this Outer
            .filter(i -> innerKeyFunc.apply(i).equals(outerKeyFunc.apply(o)))
            .forEach(i -> {
                if (matches.containsKey(o)) {
                    //This Outer already had matches, so add this Inner to the List
                    matches.get(o).add(i);
                } else {
                    //This is the first Inner to match this Outer, so create a List
                    List<Inner> list = new ArrayList<>();
                    list.add(i);
                    matches.put(o, list);
                }
            }));

    matches.forEach((out, in) -> in.stream()
            //Map each (Outer, Inner) pair to the appropriate Result...
            .map(i -> resultFunc.apply(out, i))
            //...and collect them
            .forEach(res -> results.add(res)));

    //Return the result as a Stream, like the .NET method does (IEnumerable)
    return results.stream();
}

I only did a brief test of the code using the following inputs:

public static void main(String[] args) {
    Stream<String> strings = Arrays.asList("a", "b", "c", "e", "f", "d").stream();
    Stream<Integer> ints = Arrays.asList(1, 2, 3, 6, 5, 4).stream();
    Stream<String> results = join(strings, ints, 
            Function.identity(),
            str    -> Integer.parseInt(str, 16) - 9, 
            (o, i) -> "Outer: " + o + ", Inner: " + i);
    results.forEach(r -> System.out.println(r));
}

• The int s are their own keys, so no transformation
• The Strings are mapped to int s according to their hex value - 9
• (The elements match if the int values are equal, as per default)
• Matching pairs are put into a String

The following (correct) results are printed:

Outer: a, Inner: 1
Outer: b, Inner: 2
Outer: c, Inner: 3
Outer: d, Inner: 4
Outer: e, Inner: 5
Outer: f, Inner: 6

More in-depth testing will be needed, of course, but I believe this implementation to be correct. It could probably be more efficient as well, I'm open to suggestions.

Answer 3

I also came from C# and missed that feature. One big advantage would be to have readable code by expressing intention. So I wrote my own streamjoin which works like C# Enumerable.Join(). Plus: it tolerates null-keys.

Stream<BestFriends> bestFriends = 
 join(listOfPersons.stream())
  .withKey(Person::getName)
  .on(listOfDogs.stream())
  .withKey(Dog::getOwnerName)
  .combine((person, dog) -> new BestFriends(person, dog))
  .asStream();