Is There a More Efficient Java 8 Stream approach for finding the index in an int[]?

Question

Based upon a BlackJack Question, I got to wondering about how to indicate all of the winning hands. The original question simply asked, in effect, about the maximum of two numbers not greater than 21. So a method like

public int blackjack(int a, int b);

However, what if one wished to return all of the winning hands (assuming the location in the input array was a seat at a table), so a signature such as:

/**
 * returns an array indicate the index in the specified hands that
 * correspond to the winning locations. Will return an empty array if
 * there are no winners. The length of the returned array is how many
 * winning hands there were
 * @param hands The total for each hand, where the index is the seat
 * @return the index/"seat" where a winning hand was found; may return
 *    an empty array
 */
public int[] blackjack(int[] hands) { ... }

So based upon input data such as (just using 3 "players" at "seats" 0, 1, 2):

{ 17, 15, 23 }
{ 23, 25, 22 }
{18, 16, 18 }
{16, 21, 20}

I would expect output along the lines of:

Hands: [17, 15, 23] has winners at [0]
Hands: [23, 25, 22] has no winners
Hands: [18, 16, 18] has winners at [0, 2]
Hands: [16, 21, 20] has winners at [1]

In times past, I would have iterated the hands[] array, found the maximum that was <= 21, and then iterated again finding each index that was equal to the maximum. So something like this:

public static int[] blackjackByIteration(int[] hands)
{
    int max = 0;
    int numAtMax = 0;
    for (int i = 0; i < hands.length; ++i) {
        if (hands[i] <= 21 && hands[i] > max) {
            max = hands[i];
            numAtMax = 1;
        }
        else if (hands[i] == max) {
            ++numAtMax;
        }
    }

    int[] winningSeats = new int[numAtMax];

    int loc = 0;
    for (int i = 0; i < hands.length; ++i) {
        if (hands[i] == max) {
            winningSeats[loc++] = i;
        }
    }

    return winningSeats;
}

However, I was wondering if there was a more efficient way to implement it via streams. I am cognizant that using Lambdas is not the solution to all problems. I believe, if I have read correctly, that is not possible to find the index of an int[] array directly, so the approach must rely upon using a List<Integer>, as suggested in the question referenced above.

I made an initial solution using Streams, but was wondering if there was a more efficient approach. I fully admit my understand of streams is limited.

public static int[] blackjackByStreams(int[] hands)
{
    // set to an empty array; no winners in this hand
    int[] winningSeats = new int[0];

    // get the maximum that is <= 21
    OptionalInt oi = Arrays.stream(hands).filter(tot -> tot <= 21).max();

    // if there are any hands that are <= 21
    if (oi.isPresent()) {
        // have to make a list (?) 
        List<Integer> list = Arrays.stream(hands)
                                    .boxed()
                                    .collect(Collectors.toList());

        // find the location(s) in the list
        winningSeats = IntStream.range(0, list.size())
                      .filter(i -> list.get(i) == oi.getAsInt())
                      .toArray();
    }

    return winningSeats;
}

The two approaches return the same data, so it is not a question of functionality per se. Rather, is there any way to make the blackjackByStreams better? Especially, is there a way to eliminate the creation of the List<Integer> list?

Edit: I did read this question here, in which one answer suggested creating a custom collector. Not sure if that would be the only alternative approach.

Thank you for providing any insight.

Streams do not, generally speaking, improve efficiency. Streams will generally be no faster, and often slower, than the same program written out normally. They're just a library, they're not magic. Your initial code will be at least as fast and probably faster. — Louis Wasserman, Apr 25 '16 at 21:22

score 4 · Accepted Answer · answered Apr 25 '16 at 21:47

4

You're missing the simple solution when you have found the maximum element. Just create a Stream over the indexes of the array directly instead of having an intermediate list:

public static int[] blackjackByIteration(int[] hands) {
    OptionalInt oi = Arrays.stream(hands).filter(i -> i <= 21).max();
    if (oi.isPresent()) {
        int value = oi.getAsInt();
        return IntStream.range(0, hands.length).filter(i -> hands[i] == value).toArray();
    }
    return new int[0];
}

answered Apr 25 '16 at 21:47

Tunaki

132,869
46
340
423

I thought I had tried that and received an error, but in thinking about it probably tried using `Arrays.stream(hands)...` rather than the `IntStream.range(0, hands.length)...`. Large improvement in the conciseness of the method! – KevinO Apr 25 '16 at 22:42
1

@Holger Not necessarily, the array could have all values greater than 21, so the OptionalInt would be empty. It's unfortunate that there is no `mapToObj` on `OptionalInt` though, otherwise we could have `oi.mapToObj(...).orElseGet(() -> new int[0])` – Tunaki Apr 26 '16 at 09:29
1

Indeed, that’s complicating matter. I should have another coffee… What you could do to avoid the `if` is `int value = oi.orElse(21);` and proceed with the second stream op, which will produce an empty array when there are no matches. I still think, there should be something easier… – Holger Apr 26 '16 at 09:33

Is There a More Efficient Java 8 Stream approach for finding the index in an int[]?

1 Answers1