web-dev-qa-db-fra.com

Utilisation de flux au lieu de boucle pour Java 8

int [] numbers = {1,2,3,4,5,6,7,8};
int [] doubleNumbers = new int[numbers.length];
int [] tripleNumbers = new int[numbers.length];


for(int index = 0; index < numbers.length; index++)
{
    doubleNumbers[index] = numbers[index] * 2;  
    tripleNumbers[index] = numbers[index] * 3;
}

System.out.println("Double Numbers");
Arrays.stream(doubleNumbers).forEach(System.out::println);

System.out.println("Triple Numbers");
Arrays.stream(tripleNumbers).forEach(System.out::println);

J'ai code ci-dessus où j'ai utilisé pour la boucle et double et triple les numéros et stocké dans différents tableaux en simple boucle. Quelqu'un peut-il m'aider à écrire le même code en utilisant des flux avec sa carte et d'autres méthodes sans itérer le tableau de nombres deux fois.

javajava-8java-stream
6
Sarang Shinde

Vous pouvez le faire comme ça:

IntStream.range(0, numbers.length)
  .forEach(index -> {
    doubleNumbers[index] = numbers[index] * 2;
    tripleNumbers[index] = numbers[index] * 3;
  });
10
thegauravmahawar

Vous pouvez appliquer le doublement et le triplement dans le flux:

public static void main(String[] args) {
    int [] numbers = {1,2,3,4,5,6,7,8};

    System.out.println("Double Numbers");
    Arrays.stream(numbers).map(x -> x*2).forEach(System.out::println);

    System.out.println("Triple Numbers");
    Arrays.stream(numbers).map(x -> x*3).forEach(System.out::println);
}

bien que techniquement, cela se répète encore deux fois sur le tableau.

Comme astuce, vous pouvez plutôt collecter les résultats dans une carte:

    Map<Integer, Integer> m = Arrays.stream(numbers)
        .boxed()
        .collect(Collectors.toMap(
            x -> x*2,
            x -> x*3
        ));
3
jon-hanson

On dirait que votre question est plus compliquée que d'utiliser simplement l'API Java Stream. La meilleure façon est de définir une classe d’emballage comme Num.class:

class Num {
    private final int value;

    //constructor

    public int powerOf(int index) {
        return Math.pow(value, index);
    }

}

Ensuite, vous pouvez simplement envelopper vos éléments de tableau dans cet objet et appeler la méthode powerOf où vous avez besoin. Avec votre implémentation, vous créez des tableaux inutiles pour conserver les valeurs optimisées. Et utiliser Stream API dans ce cas est plus pratique:

Arrays.stream(numbers).map(Num::new).forEach(n -> System.out.println("power of 2": + n.powerOf(2));
2
eg04lt3r

Vous pouvez utiliser stream avec forEach pour peupler collections de doubles et de triples, par exemple:

public static void main(String[] args) {
    int [] numbers = {1,2,3,4,5,6,7,8};
    List<Integer> doubles = new ArrayList<Integer>();
    List<Integer> triples = new ArrayList<>();

    Arrays.stream(numbers)
    .boxed()
    .forEach(n -> {
        doubles.add(n*2);
        triples.add(n*3);
        }
    );

    System.out.println(doubles);
    System.out.println(triples);
}

Un autre exemple avec map et collect:

public static void main(String[] args) {
    int [] numbers = {1,2,3,4,5,6,7,8};

    List<Integer> doubles = Arrays.stream(numbers)
    .boxed()
    .map(n -> n*2)
    .collect(Collectors.toList());

    List<Integer> triples = Arrays.stream(numbers)
            .boxed()
            .map(n -> n*3)
            .collect(Collectors.toList());

    System.out.println(doubles);
    System.out.println(triples);
}
1
Darshan Mehta