Stream Gatherers-ը գործնականում, մաս 1
Առաջին քայլը Java 22-ի գրավիչ նոր հնարավորության՝ Stream Gatherers-ի ուսումնասիրության ճանապարհին, ուշադրությունը՝ իրական խնդիրներ լուծող սեփական Gatherer-ների ստեղծման վրա։
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-ների հետ աշխատանքը դարձնում է և՛ ավելի հաճելի, և՛ ավելի արդյունավետ։