Java 8 flux sur les tableaux de chaînes

J'ai une seule Chaîne de format:

row1col1 row1col2
row2col1 row2col2
row3col1 row3col2

et ainsi de suite...

Je veux extraire de chaque élément et de construire un tableau d'objets avec des propriétés comme ceci:

new MyObject(row1col1, row1col2);

Je suis nouveau sur Java 8 et les Ruisseaux, et je voudrais savoir comment puis-je obtenir sans boucles.

Normalement, je voudrais utiliser une String.split('\n') pour l'accumulation de la lignes dans un tableau de String

Et puis une boucle où pour chaque ligne je voudrais diviser à nouveau sur l'espace comme séparateur et avec la matrice résultante de deux éléments (row1col1 row1col2) construire mon objet, jusqu'à ce qu'il n'y a plus de lignes à traiter.

Comme ceci:

String sausage = "row1col1 row1col2\nrow2col1 row2col2\nrow3col1 row3col2";
String[] rows = sausage.split("\n");

for (String row : rows) {
    String[] objectData = u.split("\\s+");
    MyObject myObject = new MyObject(objectData[0], objectData[1]);
    myObjectList.add(myObject);
}

Quelqu'un peut-il m'expliquer comment réaliser la même chose avec des ruisseaux et quel est le mécanisme derrière qui me permet de le faire?

Est-ce encore un moyen valable de penser lorsque l'on augmente le nombre d'éléments, car, de tous les exemples que j'ai vu le flux focus sur le filtrage, la collecte ou, généralement, étant donné un ensemble d'éléments de récupérer un mineur mis en appliquant certains critères.

source d'informationauteur Lucian Enache

  1. 11

    Un moyen simple serait de créer un Pattern avec le séparateur de ligne et de diviser l'entrée String comme un Stream. Ensuite, chaque ligne est divisée par un espace (en ne gardant que 2 parties) et associée à un MyObject. Enfin, un tableau est construit avec le résultat.

    public static void main(String[] args) {
    String str = "row1col1 row2col2\r\nrow2col1 row2col2\r\nrow3col1 row3col2";

    MyObject[] array =
        Pattern.compile(System.lineSeparator(), Pattern.LITERAL)
               .splitAsStream(str)
               .map(s -> s.split("\\s+", 2))
               .map(a -> new MyObject(a[0], a[1]))
               .toArray(MyObject[]::new);

    System.out.println(Arrays.toString(array));
}

    À l'aide de splitAsStream peut être plus avantageux que les Stream.of(...) si l'entrée String est longue.

    J'ai supposé que dans le code que le séparateur de ligne de la String était le défaut de séparateur de ligne (System.lineSeparator()) de l'OS, mais vous pouvez le changer si il ne l'est pas.

    Au lieu de cela, si vous lisez à partir d'un fichier, vous pouvez utiliser Files.lines() pour obtenir une prise d'un Stream de toutes les lignes dans le fichier:

    MyObject[] array = Files.lines(path)
                        .map(s -> s.split("\\s+", 2))
                        .map(a -> new MyObject(a[0], a[1]))
                        .toArray(MyObject[]::new);

System.out.println(Arrays.toString(array));
  2. 5

    Vous pouvez générer un Stream de Strings qui représentent un seul MyObject exemple, et de transformer chacun d'eux à votre MyObject instance (par premier de les diviser à nouveau, puis la construction d'un MyObject exemple) :

    List<MyObject> list = 
   Stream.of(inputString.split("\n"))
      .map (s -> s.split(" "))
      .filter (arr -> arr.length == 2) //this validation may not be necessary
                                       //if you are sure each line contains 2 tokens
      .map (arr -> new MyObject(arr[0],arr[1]))
      .collect(Collectors.toList());