Գնահատել նախագիծը
← Բոլոր հրապարակումները

Stream Gatherers-ը գործնականում, մաս 1

Առաջին քայլը Java 22-ի գրավիչ նոր հնարավորության՝ Stream Gatherers-ի ուսումնասիրության ճանապարհին, ուշադրությունը՝ իրական խնդիրներ լուծող սեփական Gatherer-ների ստեղծման վրա։

10 րոպե
JavaՖունկցիոնալ ծրագրավորումuncoverjavajava22stream gatherersstream

Java 22-ը բերում է գրավիչ preview հնարավորություն՝ JEP 461: Stream Gatherers, որը Stream API-ի կարևոր թարմացումն է։ Նրա հիմքում նոր gather մեթոդն է, որը API-ն դարձնում է ավելի կարգավորելի, ճկուն և արդյունավետ։ Նրա նպատակներն են.

  • Stream API-ն դարձնել ավելի հարմարվողական՝ հնարավորություն տալով ստեղծել հատուկ կարիքներին ավելի լավ համապատասխանող stream գործողություններ։
  • Բարելավել stream-վրա հիմնված խնդիրների կոդի վերօգտագործելիությունը։
  • Բարդ stream գործողությունները դարձնել ավելի հեշտ հասկանալի և իրականացվող։

Կարևոր է, որ այս ամենը ձեռք է բերվում առանց գոյություն ունեցող Stream API-ն շատ ավելի բարդացնելու։

Այս ուսումնասիրությունը երկու մասից է. այս հոդվածը ներկայացնում է Gatherer-ների հիմնարար հասկացությունները և դրանց կիրառումը գործնական գործողություններում։ Հաջորդը կքննարկի ներկառուցված gatherer-ները և դրանք բարդ գործողությունների մեջ համադրելը։

Gatherer ինտերֆեյսի ըմբռնում

Gatherer ինտերֆեյսը JEP 461-ի հիմքում է և Java 22-ում հնարավորություն է տալիս կարգավորել stream գործողությունները։ Այն կազմված է մի քանի հիմնական մեթոդներից, որոնք աջակցում են տվյալների բարդ մշակմանը պարզեցված, արդյունավետ եղանակով.

  • Initializer մեթոդ. Ընտրովի է և հատկապես կարևոր է, երբ integrator-ը կամ finisher-ը օգտագործում է ներքին վիճակ։ Այդ դեպքում Initializer մեթոդը պատասխանատու է այդ ներքին վիճակը ճիշտ սկզբնավորելու համար նախքան որևէ տվյալի մշակումը։
  • Integrator մեթոդ. Միշտ պետք է իրականացվի։ Սա կենտրոնական մեթոդն է, որը սահմանում է տվյալների մշակման իրական տրամաբանությունը։ Յուրաքանչյուր Gatherer-ին այն պետք է՝ սահմանելու համար, թե ինչպես է մշակվում stream-ի յուրաքանչյուր տարր և ներառվում ընթացիկ վիճակի մեջ։
  • Finisher մեթոդ. Այն իրականացնելը ընտրովի է։ Այն զբաղվում է վերջնական մշակմամբ և փոխակերպումներով, երբ բոլոր տարրերը ներառվել են։
  • Combiner մեթոդ. Այն վերասահմանելը ընտրովի է։ Այս մեթոդը առանցքային է զուգահեռ stream գործողությունների համար, քանի որ սահմանում է, թե ինչպես են միավորվում stream-ի տարբեր հատվածների արդյունքները։ Այն կարևոր է, երբ stream-ը մշակվում է զուգահեռաբար, և պետք է հարմարեցվի ձեր կոնկրետ զուգահեռ մշակման կարիքներին։
  • AndThen մեթոդ։ Այն վերասահմանելը ընտրովի է։ Լռելյայն իրականացումը թույլ է տալիս gatherer կառուցել այլ gatherer-ներից։

Stream::gather մեթոդը աշխատում է Gatherer ինտերֆեյսի հետ ձեռք ձեռքի տված՝ ապահովելով stream-ների մշակման ավելի արտահայտիչ և ճկուն եղանակ։ Stream::gather-ին Gatherer ինստանս փոխանցելով՝ ծրագրավորողները կարող են կառուցել իրենց կարիքներին համապատասխան սեփական գործողություններ՝ դուրս գալով Stream API-ի նախասահմանված գործողությունների սահմաններից։

Սեփական Gatherer-ների իրականացում

Այս բաժնում կդիտարկենք, թե ինչպես կարելի է գործնականում օգտագործել Java 22-ում Stream API-ին ավելացված gather մեթոդը։ Նրա բազմակողմանիությունն ու հզորությունը ցույց տալու համար կկառուցենք մի քանի սեփական gatherer՝ հատուկ այդ նպատակով գրված Money դասի վրա։ Այս օրինակները ցույց կտան, թե ինչպես կարող է gather մեթոդը պարզեցնել և բարելավել բարդ տվյալների տիպերի վրա գործողությունները՝ լույս սփռելով այս նոր հնարավորության և՛ գործնական արժեքի, և՛ նորարարական ներուժի վրա։ Ինչպես նշվեց, Stream Gatherers-ը դեռ preview փուլում է, ուստի ֆունկցիոնալությունը պետք է միացնել JVM դրոշակով՝ –enable-preview։

public record Money(BigDecimal amount, Currency currency) {
   public Money add(Money money) {
       return new Money(money.amount.add(this.amount), currency);
   }

   public Money multiply(BigDecimal multiplier) {
       return new Money(amount.multiply(multiplier), currency);
   }
}

Distinct by Gatherer

Որպեսզի ցույց տանք, թե ինչի համար է gather մեթոդը, սկսենք DistinctByGatherer-ից։ Այն stream-ի տարրերը պահում է եզակի՝ ըստ ընտրիչ ֆունկցիայի, ինչ Stream API-ն արկղից դուրս չի աջակցում։

public class DistinctByGatherer<T, P> implements Gatherer<T, Set<P>, T> {

   private final Function<T, P> selector;

   public DistinctByGatherer(Function<T, P> selector) {
       this.selector = selector;
   }

   @Override
   public Supplier<Set<P>> initializer() {
       return HashSet::new;
   }

   @Override
   public Integrator<Set<P>, T, T> integrator() {
       return Integrator.ofGreedy((state, item, downstream) -> {
           P extracted = selector.apply(item);
           if(!state.contains(extracted)) {
               state.add(extracted);
               downstream.push(item);
           }

           return true;
       });
   }
}

Այստեղ DistinctByGatherer-ը հենվում է.

  • Initializer-ի վրա, որը սահմանում է ներքին վիճակը՝ մասնավորապես այն բազմությունը, որը հետևում է արդեն տեսած տարրերին։
  • Integrator-ի վրա, որը երաշխավորում է տարրերի եզակիությունը՝ ըստ տրված ընտրիչ ֆունկցիայի։ Այն աշխատում է հետևյալի հետ.
    • state. պահում է initializer() ֆունկցիայով ստեղծված ներքին բազմությունը, որն օգտագործվում է եզակի տարրերին հետևելու համար։
    • item. մուտքային stream-ի ներկայումս մշակվող տարրը։
    • downstream. pipeline-ի հաջորդ փուլը, որը ստանում է տարրը, եթե այն անցնում է եզակիության ստուգումը։

Հեշտ օգտագործման համար ավելացնում ենք factory դաս՝ MyGatherers.

public class MyGatherers {
   public static <T, P> DistinctByGatherer<T, P> distinctBy(Function<T, P> extractor) {
       return new DistinctByGatherer<>(extractor);
   }
}

Այս gatherer-ի կիրառումը Money դասի վրա.

var money = List.of(
       new Money(BigDecimal.valueOf(12), PLN),
       new Money(BigDecimal.valueOf(11), EUR),
       new Money(BigDecimal.valueOf(15), PLN)
);

System.out.println("\nDistinct By Currency:");
money.stream()
       .gather(MyGatherers.distinctBy(Money::currency))
       .forEach(System.out::println);

Արդյունք.

Distinct By Currency:
Money[amount=12, currency=PLN]
Money[amount=11, currency=EUR]

DistinctByGatherer-ը ստանդարտ Stream::distinct մեթոդի նրբացված ընդլայնումն է, որը ապահովում է ավելի մեծ ճկունություն և ավելի հարուստ ֆիլտրում՝ հիմնված սեփական չափանիշների վրա՝ առարկաների պարզ հավասարության փոխարեն։

Reduce by Gatherer

Հիմա դիտարկենք ReduceByGatherer-ը, որը ագրեգացնում է stream-ի տարրերը՝ ըստ ընտրիչ ֆունկցիայի։ DistinctByGatherer-ից տարբերվելով՝ այն կրկնօրինակները բաց չի թողնում, այլ միավորում է մեկից ավելի անգամ հանդիպող տարրերը։

public class ReduceByGatherer<T, P> implements Gatherer<T, Map<P, T>, T> {
   private final Function<T, P> selector;
   private final BiFunction<T, T, T> operation;

   public ReduceByGatherer(Function<T, P> extractor, BiFunction<T, T, T> reducer) {
       this.selector = extractor;
       this.operation = reducer;
   }

   @Override
   public Supplier<Map<P, T>> initializer() {
       return HashMap::new;
   }

   @Override
   public Integrator<Map<P, T>, T, T> integrator() {
       return Integrator.ofGreedy((state, item, _) -> {
           state.merge(selector.apply(item), item, operation);
           return true;
       });
   }

   @Override
   public BiConsumer<Map<P, T>, Downstream<? super T>> finisher() {
       return (state, downstream) -> state.values().forEach(downstream::push);
   }
}

Ստորև ReduceByGatherer-ի հիմնական կողմերը նկարագրող բաժնի վերանայված, ավելի մանրակրկիտ տարբերակն է.

ReduceByGatherer-ի հիմնական կողմերը.

  • Վիճակի կառավարում. Իր վիճակը պահելու համար օգտագործում է HashMap, ինչը թույլ է տալիս stream-ի տարրերը արդյունավետ ագրեգացնել։
  • Integrator-ի իրականացում. Stream-ը մշակելիս տարրերը միավորում է՝ հետևելով տրված ընտրիչ և reducer ֆունկցիաներին։ Նախորդ օրինակների պես մշակված տարրերն անմիջապես դեպի downstream ուղարկելու փոխարեն՝ այս մեթոդը պետք է դրանք պահի HashMap-ում՝ վիճակի կառավարման համար։
  • Finisher-ի իրականացում. Գործընթացն ավարտում է՝ կուտակված արժեքները դեպի downstream հրելով բոլոր տարրերը մշակելուց հետո։ Սա էական է reduce գործողությունների համար, որոնցում բոլոր տարրերը պետք է մշակվեն միասին՝ վերջնական արդյունք ստանալուց առաջ։
  • Stream-ի լրիվ մշակում. Ի տարբերություն վաղ ավարտ թույլ տվող գործողությունների (օրինակ՝ takeWhile), ReduceByGatherer-ը ճիշտ արդյունք ստանալու համար պետք է մշակի stream-ի յուրաքանչյուր տարր։

ReduceByGatherer-ի ավելացումը մեր օգնական դասին.

public class MyGatherers {
   public static <T, P> DistinctByGatherer<T, P> distinctBy(Function<T, P> extractor) {
       return new DistinctByGatherer<>(extractor);
   }

   public static <T, P> ReduceByGatherer<T, P> reduceBy(Function<T, P> extractor, BiFunction<T, T, T> reducer) {
       return new ReduceByGatherer<>(extractor, reducer);
   }
}

Օրինակ Money դասի հետ.

var money = List.of(
       new Money(BigDecimal.valueOf(12), PLN),
       new Money(BigDecimal.valueOf(11), EUR),
       new Money(BigDecimal.valueOf(15), PLN)
);

System.out.println("Reduce By Currency");
money.stream()
       .gather(MyGatherers.reduceBy(Money::currency, Money::add))
       .forEach(System.out::println);

Արդյունք.

Reduce By Currency
Money[amount=27, currency=PLN]
Money[amount=11, currency=EUR]

Այս gatherer-ը stream-ի տարրերը միավորում է արդյունավետորեն, ինչը այն դարձնում է հիանալի ընտրություն վերջավոր stream-ում տվյալները սեղմելու կամ ագրեգացնելու համար։

Max by Gatherer

MaxByGatherer-ը գտնում է stream-ի ամենամեծ տարրը՝ ըստ տրված ընտրիչ ֆունկցիայի։ Նրա իրականացումը ավելի բարդ է, քանի որ ավելացնում է վիճակը կառավարելու առանձին դաս և combiner ֆունկցիա, որը բարելավում է զուգահեռ stream գործողությունների աջակցությունը։

class MaxByGatherer<T, B extends Comparable<B>> implements Gatherer<T, State<T>, T> {
   private final Function<T, B> extractor;

   MaxByGatherer(Function<T, B> extractor) {
       this.extractor = extractor;
   }

   @Override
   public Supplier<State<T>> initializer() {
       return State::new;
   }

   @Override
   public Integrator<State<T>, T, T> integrator() {
       return Integrator.ofGreedy((state, item, _) -> {
           if (state.maxElement == null) {
               state.maxElement = item;
               return true;
           }

           B currentItemValue = extractor.apply(item);
           B maxItemValue = extractor.apply(state.maxElement);

           if (currentItemValue.compareTo(maxItemValue) > 0) {
               state.maxElement = item;
           }

           return true;
       });
   }

   @Override
   public BinaryOperator<State<T>> combiner() {

       return (first, second) -> {
           if (first.maxElement == null && second.maxElement == null) {
               return null;
           } else if (first.maxElement == null) {
               return second;
           } else if (second.maxElement == null) {
               return first;
           }

           B firstMaxValue = extractor.apply(first.maxElement);
           B secondMaxValue = extractor.apply(second.maxElement);

           if (firstMaxValue.compareTo(secondMaxValue) > 0) {
               return first;
           } else {
               return second;
           }
       };
   }

   @Override
   public BiConsumer<State<T>, Downstream<? super T>> finisher() {
       return (state, downstream) -> downstream.push(state.maxElement);
   }
}

class State<T> {
   T maxElement;
}

Հիմնական առանձնահատկություններ.

  • Վիճակի կառավարում. Ամենամեծ տարրին հետևում է սեփական State դասով։
  • Integrator. Գտնում է ամենամեծ տարրը՝ օգտագործելով տրված համեմատող ֆունկցիան։
  • Combiner. Միավորում է տարբեր հատվածների վիճակը՝ զուգահեռ stream-երում մշակումը դարձնելով արդյունավետ։

Այս gatherer-ը զգալիորեն ընդլայնում է Stream API-ի հնարավորությունը բարդ հաշվարկների համար, օրինակ՝ զուգահեռ մշակման ժամանակ առավելագույն արժեքներ գտնելու։

MaxByGatherer-ի ավելացումը MyGatherers-ին.

public class MyGatherers {
   public static <T, P> DistinctByGatherer<T, P> distinctBy(Function<T, P> extractor) {
       return new DistinctByGatherer<>(extractor);
   }

   public static <T, P> ReduceByGatherer<T, P> reduceBy(Function<T, P> extractor, BiFunction<T, T, T> reducer) {
       return new ReduceByGatherer<>(extractor, reducer);
   }

   public static <T, B extends Comparable<B>> MaxByGatherer<T, B> maxBy(Function<T, B> extractor) {
       return new MaxByGatherer<>(extractor);
   }
}

Օգտագործման օրինակ.

var money = List.of(
       new Money(BigDecimal.valueOf(12), PLN),
       new Money(BigDecimal.valueOf(11), PLN),
       new Money(BigDecimal.valueOf(15), PLN)
);

System.out.println("\nMax By Amount");
money.stream()
       .parallel()
       .gather(MyGatherers.maxBy(Money::amount))
       .forEach(System.out::println);

Նկատենք, որ combiner-ի իրականացումը գործի է մտնում միայն զուգահեռ stream օգտագործելիս։

Արդյունք.

Max By Amount
Money[amount=15, currency=PLN]

Այս իրականացումը ցույց է տալիս, թե ինչպես կարող է MaxByGatherer-ը արդյունավետորեն գտնել հավաքածուի առավելագույն արժեքը։

Map Not-Null Gatherer

Պատկերացրեք՝ ունենք Money օբյեկտների ցանկ, որի մեջ խառնված են null արժեքներ։ Ուզում ենք null-ները հեռացնել և մնացած տարրերը փոխակերպել։ Դա կարելի է անել Stream::filter-ը և Stream::map-ը համադրելով, բայց փորձենք ավելի պարզեցված մոտեցում՝ կառուցված Kotlin-ի mapNotNull ֆունկցիայի օրինակով։

public class MapNotNullGatherer<T,M> implements Gatherer<T, T, M> {
   private final Function<T, M> mapper;

   public MapNotNullGatherer(Function<T, M> mapper) {
       this.mapper = mapper;
   }

   @Override
   public Integrator<T, T, M> integrator() {
       return Integrator.ofGreedy((_, item, downstream) -> {
           if(item != null) {
               downstream.push(mapper.apply(item));
           }
           return true;
       });
   }
}

Հիմնական կետեր.

  • Պարզություն. Այս gatherer-ի անհրաժեշտ միակ մեթոդը integrator-ն է, որը հեռացնում է null-ները և ոչ-null տարրերին կիրառում է mapping ֆունկցիան։
  • Արդյունավետություն. Ֆիլտրումը և mapping-ը տեղի են ունենում մեկ քայլով, ինչը բարելավում է և՛ կոդի ընթեռնելիությունը, և՛ արտադրողականությունը։

MapNotNullGatherer-ի ավելացումը MyGatherers-ին.

public class MyGatherers {
   public static <T, P> DistinctByGatherer<T, P> distinctBy(Function<T, P> extractor) {
       return new DistinctByGatherer<>(extractor);
   }

   public static <T, P> ReduceByGatherer<T, P> reduceBy(Function<T, P> extractor, BiFunction<T, T, T> reducer) {
       return new ReduceByGatherer<>(extractor, reducer);
   }

   public static <T, B extends Comparable<B>> MaxByGatherer<T, B> maxBy(Function<T, B> extractor) {
       return new MaxByGatherer<>(extractor);
   }

   public static <T, M> MapNotNullGatherer<T, M> mapNotNull(Function<T, M> mapper) {
       return new MapNotNullGatherer<>(mapper);
   }
}

Օգտագործման օրինակ.

var moneyWithNulls = Arrays.asList(
       new Money(BigDecimal.valueOf(12), PLN),
       null,
       new Money(BigDecimal.valueOf(11), EUR),
       new Money(BigDecimal.valueOf(15), PLN),
       null
);

System.out.println("Map not-null Gatherer");
moneyWithNulls.stream()
       .gather(MyGatherers.mapNotNull(m -> m.multiply(BigDecimal.TWO)))
       .forEach(System.out::println);

Արդյունք.

Map not-null Gatherer
Money[amount=24, currency=PLN]
Money[amount=22, currency=EUR]
Money[amount=30, currency=PLN]

Այս իրականացումը ցույց է տալիս, թե ինչպես կարող են սեփական gatherer-ները stream գործողությունները դարձնել ավելի պարզ և ավելի լավը, հատկապես երբ պետք են և՛ ֆիլտրում, և՛ փոխակերպում։

Find first Gatherer

FindFirstGatherer-ը ստանդարտ Stream::findFirst մեթոդի հնարամիտ մեկնաբանություն է, որը նրանից տարբերվում է երկու հիմնական կողմերով.

  • Stream արդյունք. Մինչդեռ Stream::findFirst-ը վերադարձնում է Optional<T>, այս gatherer-ը արտադրում է Stream<T>՝ դատարկ կամ մեկ տարր պարունակող, կախված նրանից՝ predicate-ը բավարարվում է թե ոչ։
  • Predicate-ի վրա հիմնված ֆիլտրում. Այն աշխատում է predicate-ով՝ տարրերը ընտրողաբար մշակելով, մինչև գտնի առաջին համընկնումը։
public class FindFirstGatherer<T> implements Gatherer<T, T, T> {
   private final Predicate<T> predicate;

   public FindFirstGatherer(Predicate<T> predicate) {
       this.predicate = predicate;
   }

   @Override
   public Integrator<T, T, T> integrator() {
       return Integrator.ofGreedy((_, item, downstream) -> {
           if (predicate.test(item)) {
               downstream.push(item);
               return false;
           } else {
               return true;
           }
       });
   }
}

Հենց predicate-ը բավարարող տարր է գտնվում, իրականացումը դադարեցնում է հետագա տարրերի մշակումը։ Երբ դա տեղի է ունենում, integrator-ը վերադարձնում է false։

FindFirstGatherer-ի ավելացումը MyGatherers-ին.

public class MyGatherers {
   public static <T, P> DistinctByGatherer<T, P> distinctBy(Function<T, P> extractor) {
       return new DistinctByGatherer<>(extractor);
   }

   public static <T, P> ReduceByGatherer<T, P> reduceBy(Function<T, P> extractor, BiFunction<T, T, T> reducer) {
       return new ReduceByGatherer<>(extractor, reducer);
   }

   public static <T, B extends Comparable<B>> MaxByGatherer<T, B> maxBy(Function<T, B> extractor) {
       return new MaxByGatherer<>(extractor);
   }

   public static <T, M> MapNotNullGatherer<T, M> mapNotNull(Function<T, M> mapper) {
       return new MapNotNullGatherer<>(mapper);
   }

   public static <T> FindFirstGatherer<T> findFirst(Predicate<T> predicate) {
       return new FindFirstGatherer<>(predicate);
   }
}

Օգտագործման օրինակ.

var money = List.of(
       new Money(BigDecimal.valueOf(12), PLN),
       new Money(BigDecimal.valueOf(11), PLN),
       new Money(BigDecimal.valueOf(15), PLN)
);

System.out.println("Find first Gatherer");
money.stream()
       .gather(MyGatherers.findFirst(m -> m.currency().equals(PLN)))
       .forEach(System.out::println);

Արդյունք.

Find first Gatherer
Money[amount=12, currency=PLN]

Այս gatherer-ը նրբագեղ պատասխան է առաջարկում այն դեպքերի համար, երբ մեզ պետք է միայն առաջին համապատասխան տարրը՝ գործընթացը պարզեցնելով ավելի ֆունկցիոնալ ոճով։

Ամփոփում

Այս հոդվածում մանրակրկիտ ուսումնասիրվեց JEP-461: Stream Gatherers-ը՝ Java 22-ում ավելացված preview հնարավորությունը։ Սկսեցինք նրա հիմնական հասկացությունների վերլուծությունից, ապա կառուցեցինք մի շարք գործողություններ՝ ցույց տալով նրա օգտակարությունը կոնկրետ իրավիճակներում։ Այս փորձերը ակնհայտ են դարձնում, որ Stream API-ի այս նոր աբստրակցիան մեծապես բարելավում է stream գործողությունների կարգավորելիությունը, վերօգտագործելիությունը և ընդհանուր հստակությունը՝ ողջունելի քայլ Java-ում տվյալների մշակման համար։

Հաջորդ հոդվածում կբացահայտենք Stream Gatherers-ի ողջ ներուժը՝ դիտարկելով ներկառուցված gatherer-ները և այն, թե ինչպես կարելի է Gatherer կազմել այլ Gatherer-ներից։

Կիսվեք ձեր մտքերով այս բարելավման և Java-ի առաջիկա թողարկումներում կայուն հնարավորություն դառնալու նրա շանսերի մասին։ Իմ տեսակետից սա հուզիչ փոփոխություն է, որը stream-ների հետ աշխատանքը դարձնում է և՛ ավելի հաճելի, և՛ ավելի արդյունավետ։