Stream Gatherers գործնականում, մաս 2
Մեր ճանապարհորդությունը Stream Gatherers-ի աշխարհում, որոնք Java 22-ում ավելացվեցին JEP 461-ի միջոցով, շարունակվում է. այս անգամ անդրադառնում ենք ներկառուցված gatherer-ներին և նայում, թե ինչ կարող են դրանք անել։
Այս հոդվածում ուսումնասիրում ենք Stream Gatherers-ը, որոնք Java 22-ում հայտնվեցին JEP 461-ի միջոցով։ Կենտրոնանում ենք ներկայացված ներկառուցված gatherer-ների վրա և նայում, թե ինչ կարող են դրանք անել։ Մենք նաև կխորանանք ավելի բարդ գործողություններ ստեղծելու մեջ՝ այս ներկառուցված gatherer-ները կոմպոզիցիայի ենթարկելով՝ ցույց տալով լրացուցիչ ֆունկցիոնալությունն ու ճկունությունը, որ դրանք ավելացնում են Java-ի Stream API-ին։ Այս ուսումնասիրության նպատակն է ցույց տալ, թե որտեղ են այս հզոր գործիքները օգտակար դառնում stream-երի մշակման մեջ և ինչ են դրանք բերում։
Ներկառուցված Gatherer-ների ակնարկ
Այս բաժնում քննարկում ենք այնպիսի ներկառուցված gatherer-ներ, ինչպիսիք են fold, mapConcurrent, scan, windowFixed և windowSliding՝ տալով յուրաքանչյուրի կարճ նկարագրությունը, ապա ցույց տալով այն գործողության մեջ։
Fold
Այս Gatherer-ը stream-ի մշակման ընթացքում միավորում է տարրերը մեկ արդյունքի մեջ, ճիշտ Stream::reduce-ի նման։ Տարբերությունն այն է, որ reduce-ը իր արդյունքը փաթաթում է Optional-ի մեջ, մինչդեռ Fold-ը ուղղակիորեն վերադարձնում է stream, որը պարունակում է վերջնական ագրեգացված արժեքը։
Վերցնենք պարզ օրինակ, որը հաշվում է ֆակտորիալը.
System.out.println("Fold example:");
Stream.of(1, 2, 3, 4, 5)
.gather(Gatherers.fold(() -> 1, (a, b) -> a * b))
.forEach(System.out::println);
Ինչպես երևում է, fold-ի factory մեթոդը ընդունում է երկու արգումենտ.
- initial. Supplier, որը տալիս է fold գործողության սկզբնական արժեքը
- folder. BiFunction, որն օգտագործվում է տարրերը իրար հետևից համադրելու համար
Ելք.
Fold example:
120
Map Concurrent
«Map Concurrent» գործողությունը թույլ է տալիս ֆունկցիաներին զուգահեռաբար աշխատել stream-ի տարրերի վրա՝ սահմանափակված զուգահեռության առավելագույն մակարդակով և հիմնված վիրտուալ թելերի (virtual threads) վրա՝ պահպանելով stream-ի կարգը անփոփոխ։
Ահա, թե ինչպես օգտագործել այն յուրաքանչյուր տարրը կրկնապատկելու համար.
System.out.println("Map concurrent example:");
Stream.of(1, 2, 3, 4, 5)
.gather(Gatherers.mapConcurrent(4, a -> a *2))
.forEach(System.out::println);
Մեթոդը ընդունում է երկու պարամետր.
- maxConcurrency. սահմանում է ցանկալի զուգահեռության մակարդակը։
- mapper. Function, որը կիրառվում է յուրաքանչյուր տարրի վրա
Ելքը ցույց է տալիս արդյունավետ զուգահեռ մշակում. յուրաքանչյուր թիվը կրկնապատկվում է, և սկզբնական կարգը պահպանվում է.
Map concurrent example:
2
4
6
8
10
Scan
Այս Gatherer-ը կատարում է Prefix Scan՝ տրված ֆունկցիաներով քայլ առ քայլ կուտակելով արդյունքները։ Այն սկսվում է Supplier-ից ստացված սկզբնական արժեքով, և stream-ի յուրաքանչյուր տարրի համար BiFunction է կիրառվում ընթացիկ և հաջորդ տարրի վրա։ Այնուհետև յուրաքանչյուր կուտակված արդյունք արտանետվում է ներքև, ինչը հնարավոր է դարձնում դինամիկ կերպով ստանալ աստիճանաբար կուտակվող արժեքների հաջորդականություն։
Եկեք նորից օգտագործենք scan մեթոդը ֆակտորիալները հաշվելու համար.
System.out.println("Scan example:");
Stream.of(1, 2, 3, 4, 5)
.gather(Gatherers.scan(()->1, (a,b) -> a*b))
.forEach(System.out::println);
Fold մեթոդից տարբեր, scan-ը stream-ին ստիպում է ցույց տալ հաշվարկի յուրաքանչյուր միջանկյալ քայլը, ոչ միայն վերջնական արդյունքը.
Scan example:
1
2
6
24
120
Window Fixed
Այն դասավորում է stream-ի տարրերը հաջորդական, կարգավորված խմբերի՝ ֆիքսված չափի։ Դատարկ stream-ը պատուհաններ չի արտադրում։ Վերջին պատուհանը կարող է պարունակել ավելի քիչ տարրեր, երբ stream-ում տարրերի ընդհանուր թիվը հավասարաչափ չի բաժանվում պատուհանի չափի վրա։
Ահա օրինակ, որը stream-ի տարրերը բաժանում է երկուական տարրերից բաղկացած պատուհանների.
System.out.println("Window fixed example:");
Stream.of(1, 2, 3, 4, 5)
.gather(Gatherers.windowFixed(2))
.forEach(System.out::println);
Ստանում ենք հետևյալ ելքը.
Window fixed example:
[1, 2]
[3, 4]
[5]
Նկատում ենք, որ վերջին խումբը պարունակում է ընդամենը մեկ տարր, քանի որ stream-ն ունի կենտ քանակի տարրեր, որոնք չեն կարող հավասար բաժանվել երկուսի չափ պատուհանի վրա։
Window Sliding
«Window Sliding» Gatherer-ը տարրերը բաժանում է տրված չափի դինամիկ համընկնող պատուհանների։ Յուրաքանչյուր նոր պատուհան նախորդի համեմատ մեկ տարրով առաջ է շարժվում՝ տվյալների հոսքը պահելով անընդհատ։ Այս գործողությանը առանձնացնում է այն, որ այն արտադրում է բազմաթիվ համընկնող պատուհաններ, ուստի որոշ տարրեր հայտնվում են հաջորդական պատուհաններում՝ տալով stream-ի հաջորդականության ամբողջական պատկերը։
Աշխատեցնենք windowSliding գործողությունը նույն stream-ի վրա, ինչ առաջ.
System.out.println("Window sliding example:");
Stream.of(1, 2, 3, 4, 5)
.gather(Gatherers.windowSliding(2))
.forEach(System.out::println);
Այժմ ելքն այսպիսին է.
Window sliding example:
[1, 2]
[2, 3]
[3, 4]
[4, 5]
Այս անգամ տեսնում ենք ավելի շատ պատուհաններ, որոնցից յուրաքանչյուրը պարունակում է երկու տարր։ Նկատեք, որ որոշ տարրեր հայտնվում են երկու հաջորդական պատուհաններում։
Ներկառուցված Gatherer-ները գործողության մեջ
Հիմա, երբ հասկանում ենք, թե ինչպես են աշխատում ներկառուցված gatherer-ները, օգտագործենք դրանք ավելի գործնական խնդիրներ լուծելու համար՝ կենդանիների անվտանգ դասավորության երաշխավորում, խաղացողների միջև խաղերի սիմուլյացիա և բանկային հաշվի մնացորդի պատմության հետևում։
Կենդանիների անվտանգ դասավորություն
Կենդանիների անվտանգ դասավորության խնդիրը լուծելու համար դիտարկում ենք երեք տեսակի կենդանիներից բաղկացած հաջորդականություն.
- գայլ,
- ոչխար,
- հովվաշուն։
Հիմնական կանոնն այն է, որ երեք հաջորդական կենդանիների մեջ չի կարող լինել և՛ գայլ, և՛ ոչխար, եթե այնտեղ չկա հովվաշուն, որը կպաշտպանի այն, հակառակ դեպքում ոչխարը վտանգի մեջ է։ Մենք ուզում ենք իրականացնել վալիդացիայի տրամաբանություն, որը ստուգում է, թե արդյոք կենդանիների stream-ը բավարարում է այս կանոնին։ Որպես առաջին քայլ՝ կենդանիների տեսակները մոդելավորում ենք enum-ով՝ դնելով տրամաբանության հիմքը։
public enum Animal {
SHEEP, SHEEP_DOG, WOLF
}
Հաջորդը կստեղծենք Gatherer, որը փաթաթում է այս վալիդացիայի տրամաբանությունը.
public class AnimalStreamUtils {
public static Gatherer<Animal, ?, Boolean> isValidSequence() {
Predicate<List<Animal>> validTriplePredicate = triple -> !(
triple.contains(SHEEP) && triple.contains(WOLF) && !triple.contains(SHEEP_DOG)
);
var tripleWindowGatherer = Gatherers.<Animal>windowSliding(3);
var areAllTriplesValidGatherer = Gatherers.<List<Animal>, Boolean>fold(
() -> true,
(result, triple) -> result && validTriplePredicate.test(triple)
);
return tripleWindowGatherer.andThen(areAllTriplesValidGatherer);
}
}
Հիմնական կետեր.
- AnimalStreamUtils. օգնական դաս, որը բացահայտում է factory մեթոդ՝ Gatherer-ի միացումը դարձնելով ավելի պարզ ու հարմար։
- validTriplePredicate. ստուգում է յուրաքանչյուր եռյակը՝ հաստատելու, որ այն անվտանգ է, բացառելով իրավիճակներ, երբ գայլը կարող է սպառնալ ոչխարին։
- tripleWindowGatherer: արտադրում է վերլուծվելիք կենդանիների հաջորդական եռյակներ, որպեսզի ողջ հաջորդականությունը գնահատվի։
- areAllTriplesValidGatherer: հաստատում է, որ կենդանիների յուրաքանչյուր եռյակ անվտանգ է սահմանված չափանիշների համաձայն։
- Gatherer:andThen: այս մեթոդը gatherer-ները միավորում է մեկի մեջ. \
stream.gather(a.andThen(b))-ն անում է նույնը, ինչ stream.gather(a).gather(b)-ն։
Երբ Gatherer-ը պատրաստ է, անցնենք դրա աշխատանքը թեստավորելուն։
var validSequence = List.of(SHEEP, SHEEP_DOG, WOLF, WOLF);
System.out.println("Valid animal sequence result:");
validSequence.stream()
.gather(AnimalStreamUtils.isValidSequence())
.forEach(System.out::println);
var invalidSequence = List.of(SHEEP_DOG, SHEEP, WOLF, WOLF);
System.out.println("\nInvalid animal sequence result:");
invalidSequence.stream()
.gather(AnimalStreamUtils.isValidSequence())
.forEach(System.out::println);
Աշխատեցնելը տալիս է սպասվող ելքը.
Valid animal sequence result:
true
Invalid animal sequence result:
false
Խաղերի սիմուլյացիա
Անցնենք հաջորդ խնդրին. ուզում ենք խաղացողներին զույգերի բաժանել և նրանց միջև խաղեր սիմուլացնել։ Յուրաքանչյուր խաղ ավարտվում է խաղացողներից մեկի հաղթանակով կամ ոչ-ոքիով։
Սկսում ենք պարզ Player մոդելից, որը պարունակում է միայն անուն, որն օգտագործվում է սիմուլյացիայի խաղերում յուրաքանչյուր խաղացողին նույնականացնելու համար.
public record Player(String name) {
}
Հետո ավելացնում ենք Game ինտերֆեյս երկու առանձին իրականացումներով՝ CompletedGame, որը ներկայացնում է հաջողությամբ ավարտված խաղը, և InvalidGame, որն օգտագործվում է, երբ բավարար խաղացողներ չեն եղել։
public interface Game {
Game INVALID_GAME = new InvalidGame();
static Game completedGame(Player player1, Player player2, GameResult result) {
return new CompletedGame(player1, player2, result);
}
}
record CompletedGame(Player player1, Player player2, GameResult result) implements Game {
}
class InvalidGame implements Game {
@Override
public String toString() {
return "INVALID GAME";
}
}
GameResult-ը enum է, որը նկարագրում է հնարավոր արդյունքները՝ խաղացողներից մեկը հաղթում է, կամ խաղը ոչ-ոքի է։ Այն նաև տրամադրում է մեթոդ, որը յուրաքանչյուր խաղի համար ստեղծում է պատահական արդյունք։
public enum GameResult {
PLAYER1_WON, PLAYER2_WON, DRAW;
private static final Random RANDOM = new Random();
public static GameResult randomResult() {
return switch (RANDOM.nextInt(3)) {
case 0 -> PLAYER1_WON;
case 1 -> PLAYER2_WON;
default -> DRAW;
};
}
}
Դրանից հետո կառուցում ենք Gatherer, որը խաղացողներին զույգերի է բաժանում և աշխատեցնում նրանց խաղերը՝ հոգ տանելով ամբողջ matchmaking գործընթացի մասին։
public class GameGatherers {
public static Gatherer<Player, ?, Game> performGamesGatherer() {
Gatherer<Player,?, List<Player>> pairPlayersGatherer = Gatherers.windowFixed(2);
Gatherer<List<Player>,?, Game> simulateGamesGatherer = Gatherers.mapConcurrent(4, players -> {
if(players.size() != 2) {
return Game.INVALID_GAME;
}
return Game.completedGame(players.get(0), players.get(1), GameResult.randomResult());
});
return pairPlayersGatherer.andThen(simulateGamesGatherer);
}
}
Հիմնական կետեր.
- pairPlayersGatherer: խաղացողներին դնում է զույգերի մեջ, որպեսզի նրանցից յուրաքանչյուրը խաղա ընդամենը մեկ խաղում՝ հենվելով windowFixed-ի վրա՝ մրցակցությունները կազմակերպելու համար։
- simulateGamesGatherer. սիմուլացնում է զույգերի բաժանված խաղացողների միջև խաղերը։ Երբ զույգ կազմելու համար բավարար խաղացողներ չկան, այն վերադարձնում է INVALID_GAME։ Հակառակ դեպքում ստեղծում է խաղ պատահական արդյունքով։
- andThen. վերջում երկու gatherer-ները համադրում ենք նախատեսված արդյունքը ստանալու համար։
Հիմա տեսնենք Gatherer-ը գործողության մեջ.
var listOfPlayers = List.of(
new Player("John"),
new Player("Marry"),
new Player("George"),
new Player("Ann"),
new Player("Pete"),
new Player("Stuart"),
new Player("Adam")
);
System.out.println("\nGames result:");
listOfPlayers.stream()
.gather(GameGatherers.performGamesGatherer())
.forEach(System.out::println);
Սա արտադրում է հետևյալ ելքը.
Games result:
CompletedGame[player1=Player[name=John], player2=Player[name=Marry], result=PLAYER2_WON]
CompletedGame[player1=Player[name=George], player2=Player[name=Ann], result=DRAW]
CompletedGame[player1=Player[name=Pete], player2=Player[name=Stuart], result=DRAW]
INVALID GAME
Վերջին խաղը նշվում է որպես անվավեր, որովհետև խաղացողների թիվը կենտ է, ինչը ցույց է տալիս, թե ինչպես է մեր կարգավորումը վարվում այն դեպքերում, երբ ոչ բոլորին է հնարավոր զույգ գտնել։
Բանկային հաշվի մնացորդի պատմություն
Վերջին խնդրի համար վերադառնում ենք Money record-ին, որը առաջին անգամ ներկայացվել էր Stream Gatherers-ի մասին մեր բացման հոդվածում։
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);
}
}
Money-ն դիտարկելով որպես բանկային հաշվի մնացորդի և գործարքների ներկայացում՝ ուզում ենք հետևել, թե ինչպես է մնացորդը փոխվում գործարքների շարքի ընթացքում։ Պատասխանը Gatherer գրելն է, որը ներկայացված է ստորև և արդյունավետորեն կիրառում է յուրաքանչյուր գործարքի ազդեցությունը սկզբնական մնացորդի վրա։
public class MoneyUtils {
public static Gatherer<Money, ?, Money> computeBalanceHistory(Money balance){
return Gatherers.scan(() -> balance, Money::add);
}
}
Հիմնական տարրերը.
- Սկզբնական մնացորդը, որը փոխանցվում է computeBalanceHistory մեթոդին, այն կետն է, որտեղից սկսվում է հաշվարկը։
- Gatherers::scan ֆունկցիան թարմացնում է մնացորդը stream-ի յուրաքանչյուր գործարքով՝ արտացոլելով ֆինանսական փոփոխությունները։
Փորձենք հիմա Gatherer-ը.
var transactions = List.of(
new Money(BigDecimal.valueOf(-10), PLN),
new Money(BigDecimal.valueOf(20), PLN),
new Money(BigDecimal.valueOf(50), PLN)
);
var balance = new Money(BigDecimal.valueOf(270), PLN);
System.out.println("\n Balance history:");
transactions.stream()
.gather(MoneyUtils.computeBalanceHistory(balance))
.forEach(System.out::println);
Ահա արդյունքները.
Balance history:
Money[amount=260, currency=PLN]
Money[amount=280, currency=PLN]
Money[amount=330, currency=PLN]
Որքան էլ կարճ թվա այս լուծումը, այն կարող է հարմար գալ բազմաթիվ կիրառման դեպքերում։
Ամփոփում
Stream Gatherers-ի վերաբերյալ այս շարունակական հոդվածում ավելի մոտիկից նայեցինք ներկառուցված ֆունկցիոնալությանը, ինչպիսիք են fold, mapConcurrent, scan, windowFixed և windowSliding։ Սկսեցինք ակնարկով, ապա այս gatherer-ներն օգտագործեցինք ավելի գործնական խնդիրներ լուծելու համար՝ ցույց տալով, թե որքան կիրառելի են դրանք։ Ցանկալի արդյունքներ ստանալը հաճախ նշանակում էր գիտակցաբար համադրել մի քանի gatherer andThen մեթոդով, ինչը ընդգծում է, թե որքան ճկուն և օգտակար են stream-ների մշակման այս հզոր գործիքները։
Gatherer-ները ակնհայտորեն նախատեսված են հարմարեցված լուծումներ կառուցելու համար, բայց դրանց ներկառուցված հնարավորությունները նույնպես արժեքավոր հնարավորություններ են բացում stream գործողությունների համար՝ stream-երի հետ աշխատանքը դարձնելով ավելի պարզ և լավը։
Մենք կուրախանայինք լսել ձեր կարծիքը այս ներկառուցված gatherer-ների մասին։ Օգտակար են արդյո՞ք ձեզ համար։ Կա՞ որևէ ֆունկցիոնալություն, որը, ձեր կարծիքով, պակասում է։