Lambda-Ausdruck zum Konvertieren von Array / Liste von Zeichenfolgen in Array / Liste von Ganzzahlen

Da Java 8 mit leistungsstarken Lambda-Ausdrücken geliefert wird,

Ich möchte eine Funktion schreiben, um eine Liste / ein Array von Strings in ein Array / eine Liste von Ganzzahlen, Floats, Doubles usw. zu konvertieren.

In normalem Java wäre es so einfach wie

for(String str : strList){
   intList.add(Integer.valueOf(str));
}

Aber wie erreiche ich dasselbe mit einem Lambda, wenn ein Array von Strings in ein Array von Integers konvertiert wird?

Sie können Hilfsmethoden erstellen, die eine Liste (Array) vom Typ Tin eine Liste (Array) vom Typ Umit der mapOperation on konvertieren stream.

//for lists
public static <T, U> List<U> convertList(List<T> from, Function<T, U> func) {
    return from.stream().map(func).collect(Collectors.toList());
}

//for arrays
public static <T, U> U[] convertArray(T[] from, 
                                      Function<T, U> func, 
                                      IntFunction<U[]> generator) {
    return Arrays.stream(from).map(func).toArray(generator);
}

Und benutze es so:

//for lists
List<String> stringList = Arrays.asList("1","2","3");
List<Integer> integerList = convertList(stringList, s -> Integer.parseInt(s));

//for arrays
String[] stringArr = {"1","2","3"};
Double[] doubleArr = convertArray(stringArr, Double::parseDouble, Double[]::new);

List<Integer> intList = strList.stream()
                               .map(Integer::valueOf)
                               .collect(Collectors.toList());

Die Hilfsmethoden aus der akzeptierten Antwort werden nicht benötigt. Streams können mit Lambdas verwendet oder normalerweise mithilfe von Methodenreferenzen gekürzt werden . Streams ermöglichen funktionale Operationen. map()konvertiert die Elemente und collect(...)odertoArray() verpackt den Stream wieder in ein Array oder eine Sammlung.

Venkat Subramaniams Vortrag (Video) erklärt es besser als ich.

1 Konvertieren List<String>inList<Integer>

List<String> l1 = Arrays.asList("1", "2", "3");
List<Integer> r1 = l1.stream().map(Integer::parseInt).collect(Collectors.toList());

// the longer full lambda version:
List<Integer> r1 = l1.stream().map(s -> Integer.parseInt(s)).collect(Collectors.toList());

2 Konvertieren List<String>inint[]

int[] r2 = l1.stream().mapToInt(Integer::parseInt).toArray();

3 Konvertieren String[]inList<Integer>

String[] a1 = {"4", "5", "6"};
List<Integer> r3 = Stream.of(a1).map(Integer::parseInt).collect(Collectors.toList());

4 Konvertieren String[]inint[]

int[] r4 = Stream.of(a1).mapToInt(Integer::parseInt).toArray();

5 Konvertieren String[]inList<Double>

List<Double> r5 = Stream.of(a1).map(Double::parseDouble).collect(Collectors.toList());

6 (Bonus) Konvertieren int[]inString[]

int[] a2 = {7, 8, 9};
String[] r6 = Arrays.stream(a2).mapToObj(Integer::toString).toArray(String[]::new);

Natürlich sind viel mehr Variationen möglich.

Siehe auch Ideone-Version dieser Beispiele . Kann auf Gabel klicken und dann ausführen, um im Browser ausgeführt zu werden.

BEARBEITEN: Wie in den Kommentaren erwähnt, ist dies eine viel einfachere Version: Auf Arrays.stream(stringArray).mapToInt(Integer::parseInt).toArray() diese Weise können wir die gesamte Konvertierung zu und von einer Liste überspringen.

Ich habe eine andere einzeilige Lösung gefunden, aber sie ist immer noch ziemlich langsam (dauert etwa 100-mal länger als ein for-Zyklus - getestet auf einem Array von 6000 Nullen).

String[] stringArray = ...
int[] out= Arrays.asList(stringArray).stream().map(Integer::parseInt).mapToInt(i->i).toArray();

Was dies tut:

1. Arrays.asList () konvertiert das Array in eine Liste
2. .stream konvertiert es in einen Stream (wird benötigt, um eine Karte auszuführen)
3. .map (Integer :: parseInt) konvertiert alle Elemente im Stream in Integer
4. .mapToInt (i-> i) konvertiert alle Ganzzahlen in Ints (Sie müssen dies nicht tun, wenn Sie nur Ganzzahlen möchten).
5. .toArray () konvertiert den Stream zurück in ein Array

Für Liste:

List<Integer> intList 
 = stringList.stream().map(Integer::valueOf).collect(Collectors.toList());

Für Array:

int[] intArray = Arrays.stream(stringArray).mapToInt(Integer::valueOf).toArray();

Sie können auch verwenden,

List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");

    Integer[] array = list.stream()
        .map( v -> Integer.valueOf(v))
        .toArray(Integer[]::new);

Ich habe es in den vorherigen Antworten nicht gefunden, also mit Java 8 und Streams:

Konvertieren String[]in Integer[]:

Arrays.stream(stringArray).map(Integer::valueOf).toArray(Integer[]::new)

Zusätzlich - Kontrolle, wenn das String-Array keine Elemente enthält:

Arrays.stream(from).filter(t -> (t != null)&&!("".equals(t))).map(func).toArray(generator) 

Ich habe maptoInt () mit Lambda-Operation verwendet, um einen String in eine Ganzzahl zu konvertieren

int[] arr = Arrays.stream(stringArray).mapToInt(item -> Integer.parseInt(item)).toArray();

Arrays.toString (int []) funktioniert für mich.