Perché non riesco a mappare gli interi alle stringhe durante lo streaming da un array?

Questo codice funziona (preso in Javadoc):

List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
String commaSeparatedNumbers = numbers.stream()
    .map(i -> i.toString())
    .collect(Collectors.joining(", "));

Questo non può essere compilato:

int[] numbers = {1, 2, 3, 4};
String commaSeparatedNumbers = Arrays.stream(numbers)
    .map((Integer i) -> i.toString())
    .collect(Collectors.joining(", "));

IDEA mi dice che ho una "stringa di tipo restituito incompatibile nell'espressione lambda".

Perché ? E come risolverlo?

Arrays.stream(int[])crea un IntStream, non un file Stream<Integer>. Quindi è necessario chiamare mapToObjinvece di solo map, quando si mappa un intsu un oggetto.

Questo dovrebbe funzionare come previsto:

String commaSeparatedNumbers = Arrays.stream(numbers)
    .mapToObj(i -> ((Integer) i).toString()) //i is an int, not an Integer
    .collect(Collectors.joining(", "));

che puoi anche scrivere:

String commaSeparatedNumbers = Arrays.stream(numbers)
    .mapToObj(Integer::toString)
    .collect(Collectors.joining(", "));

Arrays.stream(numbers)crea un IntStreamsotto il cofano e l'operazione di mappatura su un IntStreamrichiede una IntUnaryOperator(cioè una funzione int -> int). La funzione di mappatura che si desidera applicare non rispetta questo contratto e quindi l'errore di compilazione.

Dovresti chiamare boxed()prima per ottenere un Stream<Integer>(questo è ciò che Arrays.asList(...).stream()ritorna). Quindi chiama mapcome hai fatto nel primo snippet.

Nota che se hai bisogno di boxed()seguito da mapprobabilmente vorrai usare mapToObjdirettamente.

Il vantaggio è che mapToObjnon richiede di inscatolare ogni intvalore in un Integeroggetto; a seconda della funzione di mappatura che applichi ovviamente; quindi sceglierei questa opzione che è anche più breve da scrivere.

Puoi creare un flusso intero utilizzando Arrays.stream (int []), puoi chiamare mapToObjlike mapToObj(Integer::toString).

String csn = Arrays.stream(numbers) // your numbers array
.mapToObj(Integer::toString)
.collect(Collectors.joining(", "));

Spero che questo ti aiuti..

Niente boxe, AFAIK, e nessuna esplosione di corde aggiunte al mucchio:

public static void main(String[] args) {
    IntStream stream = IntStream.of(1, 2, 3, 4, 5, 6);
    String s = stream.collect(StringBuilder::new, (builder, n) -> builder.append(',').append(n), (x, y) -> x.append(',').append(y)).substring(1);
    System.out.println(s);
}

Se lo scopo di questo esempio e domanda è capire come mappare le stringhe a un flusso di int (ad esempio, utilizzando un flusso di int per accedere a un indice in un array di stringhe), puoi anche usare il boxing, quindi eseguire il casting su un int (che consentirebbe quindi di accedere all'indice dell'array).

int[] numbers = {0, 1, 2, 3}; 
String commaSeparatedNumbers = Arrays.stream(numbers)
    .boxed()
    .map((Integer i) -> Integer.toString((int)i))
    .collect(Collectors.joining(", "));

La chiamata .boxed () converte il tuo IntStream (un flusso di int primitivi) in un flusso (un flusso di oggetti - vale a dire, oggetti Integer) che quindi accetterà il ritorno di un oggetto (in questo caso, un oggetto String) da la tua lambda. Qui è solo una rappresentazione di stringa del numero a scopo dimostrativo, ma potrebbe essere altrettanto facilmente (e più praticamente) qualsiasi oggetto stringa, come l'elemento di un array di stringhe come menzionato prima.

Ho solo pensato di offrire un'altra possibilità. Nella programmazione, ci sono sempre più modi per svolgere un'attività. Conoscerne il maggior numero possibile, quindi scegliere quello che si adatta meglio all'attività da svolgere, tenendo presente i problemi di prestazioni, l'intuitività, la chiarezza del codice, le preferenze nello stile di codifica e la più auto-documentata.

Buona programmazione!