Рубрики

Java.util.Arrays.parallelPrefix в Java 8

Предпосылки:

Метод parallelPrefix введен в классе Arrays в java 8. Метод parallelPrefix выполняет заданную математическую функцию для элементов массива кумулятивно, и они изменяют массив одновременно.
Синтаксис:

parallelPrefix(int[] array, IntBinaryOperator op)
Parameters :
array : integer array on which operation is to be performed
op : It is of type IntBinaryOperation (It represents an operation upon two int operands
and returns a result of type int)
Exception :
NullPointerException- Throws if the array or function passed as a parameter is null

Вариации:

parallelPrefix(double[] array, DoubleBinaryOperator op)
parallelPrefix(double[] array, int fromIndex, int toIndex, DoubleBinaryOperator op)
parallelPrefix(int[] array, IntBinaryOperator op)
parallelPrefix(int[] array, int fromIndex, int toIndex, IntBinaryOperator op)
parallelPrefix(long[] array, int fromIndex, int toIndex, LongBinaryOperator op)
parallelPrefix(long[] array, LongBinaryOperator op)
parallelPrefix(T[] array, BinaryOperator op)
parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator op)

Давайте разберемся с parallelPrefix (массив int [], IntBinaryOperator op) на примере
Пример 1: он иллюстрирует, каким образом вы можете передать второй аргумент (ieIntBinaryOperator)

// Java-программа для иллюстрации parallelPrefix ()
// и демонстрируем разные способы
// передача параметра в него

import java.util.Arrays;

import java.util.function.IntBinaryOperator;

public class GFG {

      

    // Выполняет сложение

    static int compute(int x, int y) 

    {

        return x + y;

    }

  

    public static void main(String[] args) {

        int[] arr = { 2, 1, 7, 8, 4, 5, 6, 9, 8, 7, 1, 2, 3, 6, 5, 4, 7, 5 };

  

        // Раскомментируйте, чтобы увидеть работу разных методов

          

        / * Метод 1 (Создание экземпляра для IntBinaryOperator)

        // IntBinaryOperator op = (x, y) -> x + y;

        //Arrays.parallelPrefix(arr, op);

  

        // Метод 2 (Прямая передача лямбда-выражения, которое оценивается как

        // возвращаем IntBinaryOperator)

        //Arrays.parallelPrefix(arr, (x, y) -> x + y);

  

        // Метод 3 (Объявление операции в некоторой внешней функции)

        Arrays.parallelPrefix (arr, GFG :: compute); * /

        Arrays.parallelPrefix(arr, (x,y) -> compute(x,y));

          

        // Печать элементов массива

        Arrays.stream(arr).forEach(e -> System.out.print(e + "   "));

    }

}

Выход:

2   3   10   18   22   27   33   42   50   57   58   60   63   69   74   78   85   90   

Как вы можете видеть в приведенном выше примере ,rallelPrefix принимает два параметра для IntBinaryOperator. Он выполняет данное вычисление и обновляет второй элемент, сохраняя первый элемент как есть.

Пример 2: Этот пример иллюстрирует несколько операций на массив через parallelPrefix (INT [] массив, IntBinaryOperator оп) и вводит parallelPrefix (INT [] массив, Int fromIndex, Int toIndex, IntBinaryOperator ОП).

// Java-программа для демонстрации parallelPrefix
// в диапазоне заданного массива

  

import java.util.Arrays;

import java.util.function.IntBinaryOperator;

public class GFG {

  

    public static void main(String[] args) {

        int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

  

        // Пример 1

        // с примитивными типами

        // Выполняет сложение со смежным элементом, если first меньше чем

        // второй выполняет вычитание

  

        Arrays.parallelPrefix(arr, (x, y) -> {

            if (x < y)

                return x + y;

            else

                return x - y;

        });

        System.out.println("Example 1: with Primitive type");

  

        // Печать элементов массива

        Arrays.stream(arr).forEach(e -> System.out.print(e + "   "));

  

        int[] arr1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

  

        // Пример 2

        // с примитивами

        // Продолжаем умножать соседние элементы

  

        Arrays.parallelPrefix(arr1, (x, y) -> x * y);

        System.out.println("\nExample 2: with primitives");

  

        // Печать элементов массива

        Arrays.stream(arr1).forEach(e -> System.out.print(e + "   "));

  

        // Давайте рассмотрим параллельныйPrefix (массив int [], int fromIndex, int toIndex,

        // IntBinaryOperator op)

        // Используется, когда мы хотим внести изменения в указанный диапазон

        // элементы в массиве

  

        // Пример:

        // Если соседние элементы четные, тогда оба элемента заменяются

        // первый

        int[] arr2 = { 1, 2, 4, 8, 5, 9, 6, 8, 9, 10, 11 };

  

        Arrays.parallelPrefix(arr2, 2, 8, (x, y) -> {

            if (x % 2 == 0 && y % 2 == 0)

                return x;

            else

                return y;

        });

        System.out.println("\nExample: Making Changes in the "

                            +"specified range of element in an Array");

  

        // Печать элемента массива

        Arrays.stream(arr2).forEach(e -> System.out.print(e + "   "));

    }

  
}

Выход:

Example 1: with Primitive type
1   3   0   4   9   3   10   2   11   1   
Example 2: with primitives
1   2   6   24   120   720   5040   40320   362880   3628800   
Example: Making Changes in the specified range of element in an Array
1   2   4   4   5   9   6   6   9   10   11   

Пример 3: Это иллюстрирует ParallelPrefix (массив T [], BinaryOperator op) и
rallelPrefix (массив T [], int из индекса, int в индекс, операция BinaryOperator)

// Java-программа для демонстрации parallelPrefix
// в пользовательском массиве

import java.util.Arrays;

import java.util.function.IntBinaryOperator;

public class GFG {

      

    // Пользовательский класс

    static class Person{

        String name;

        int age;

          

        //конструктор

        Person(String name, int age){

            this.name = name;

            this.age = age;

        }

    }

    public static void main(String[] args) {

          

        // Работа с пользовательским классом

        Person[] p = { new Person("Geek1", 10), 

                       new Person("Geek2", 20), new Person("Geek3", 30),

                       new Person("Geek4", 40), new Person("Geek5", 50), 

                       new Person("Geek6", 60), };

  

        // Пример 1; Здесь мы преобразуем первый параметр в верхний регистр, а затем

        // объединить или добавить (в случае возраста) со вторым через

        // массив

        Arrays.parallelPrefix(p, (e1, e2) -> 

                            new Person(e1.name.toUpperCase().concat(e2.name),

                                                e1.age + e2.age));

        System.out.println("\nExample 1 :");

  

        // Печать элементов массива

        Arrays.stream(p).forEach(e -> System.out.println(e.name + "   " + e.age));

          

  

        Person[] p1 = { new Person("Geek1", 10), 

                        new Person("Geek2", 20), new Person("Geek3", 30),

                        new Person("Geek4", 40), new Person("Geek5", 50), 

                    new Person("Geek6", 60), };

  

        // Это иллюстрирует ту же модификацию, как описано выше, но внутри

        // указанный диапазон

        Arrays.parallelPrefix(p1, 1, 4, (e1, e2) -> 

                            new Person(e1.name.toUpperCase().concat(e2.name), 

                                                e1.age + e2.age));

        System.out.println("\nExample 2 :");

          

        // Печать элементов массива

        Arrays.stream(p1).forEach(e -> System.out.println(e.name + "   " + e.age));

    }

  
}

Выход:


Example 1 :
Geek1   10
GEEK1Geek2   30
GEEK1GEEK2Geek3   60
GEEK1GEEK2GEEK3Geek4   100
GEEK1GEEK2GEEK3GEEK4Geek5   150
GEEK1GEEK2GEEK3GEEK4GEEK5Geek6   210

Example 2 :
Geek1   10
Geek2   20
GEEK2Geek3   50
GEEK2GEEK3Geek4   90
Geek5   50
Geek6   60

Примечание. Параллельное использование Parallels Parefix () объясняется очень простыми операциями, которые вы можете попробовать выполнить с массивами, используя разные лямбда-выражения.

Почему мы должны использовать parallelPrefix (), когда мы можем сделать это последовательно?

  • Параллельные операции выполняются намного быстрее на массивах больших размеров, но обычно это зависит от машины.
  • Мы используем лямбду при выполнении параллельной операции, что уменьшает количество строк в коде, делая его более элегантным и читаемым

Ссылки :
https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html
Эта статья предоставлена Sumit Ghosh . Если вы как GeeksforGeeks и хотели бы внести свой вклад, вы также можете написать статью с помощью contribute.geeksforgeeks.org или по почте статьи contribute@geeksforgeeks.org. Смотрите свою статью, появляющуюся на главной странице GeeksforGeeks, и помогите другим вундеркиндам.

Пожалуйста, пишите комментарии, если вы обнаружите что-то неправильное, или вы хотите поделиться дополнительной информацией по обсуждаемой выше теме.

Рекомендуемые посты:

Java.util.Arrays.parallelPrefix в Java 8

0.00 (0%) 0 votes