JavaRush /Java Blog /Random-TK /Akym API

Dereje

28 February 2021
36 views
0 comments

Akym API

Stream API näme?

“Stream API” maglumat gurluşlary bilen işlemegiň täze usulydyr. Akym API (bir kompýuter programmasynyň başga bir programma bilen aragatnaşyk saklamagyň usullarynyň beýany) özeninde maglumatlar akymydyr. "Sapak" adalgasynyň özi, umuman, Java-da programmirlemekde gaty düşnüksiz.

“Java 8” -iň peýda bolmagy bilen, “Stream API” programmistlere ozal köp setir kodlaryny has gysga ýazmaga mümkinçilik berdi, ýagny maglumatlar toplumy bilen işi ýönekeýleşdirmek, esasanam süzgüç, sortlamak we beýleki maglumatlary manipulirlemek amallaryny ýönekeýleşdirmek. Aralyk amallaryňyz ýok bolsa, köplenç akymsyz edip bilersiňiz we etmeli, ýogsam kod akymsyz has çylşyrymly bolar.

Nireden başlamaly? Collectionygnamaga, massiwlere ýa-da usula esaslanýan we maglumatlaryň şoňa görä nireden alynjakdygyna esaslanýan Akym mysalyny döretmekden:

List<String> list = new ArrayList<String>();
       list.add("One");
       list.add("Two");
       list.add("Three");
       list.add("Four");
       list.add("Five");
       list.add("Six");
       list.add("Seven");
       list.add("Eight");
       list.add("Nine");
       list.add("Ten");
       Stream stream = list.stream();

Aboveokarda belläp geçişimiz ýaly, “Stream API” kod setirleriniň sanyny azaltmaga mümkinçilik berýär. Akym bilen mysal:

IntStream.of(50, 60, 70, 80, 90, 100, 110, 120).filter(x -> x < 90).map(x -> x + 10)
.limit(3).forEach(System.out::print);

Sapaksyz mysal:

int[] arr = {50, 60, 70, 80, 90, 100, 110, 120
	int count = 0;
	for (int x : arr) {
	    if (x >= 90) continue;
	    x += 10;
	    count++;
	    if (count > 3) break;
	    System.out.print(x);
	}

Akym döretmegiň mümkin ýollary:

Boş akym:Stream.empty()
Sanawdan akym:list.stream()
Kartadan akym:map.entrySet().stream()
Toplumdan akym:Arrays.stream(array)
Görkezilen elementlerden akym:Stream.of("1", "2", "3")

Mundan başga-da, operatorlar ýaly bir zat bar (esasan Akym synpynyň usullary). Operatorlary iki topara bölmek bolar:

Aralyk (“ýalta” hem diýilýär) - gelýän elementleri gaýtadan işlemek we akymy yzyna gaýtarmak. Elementi gaýtadan işlemek zynjyrynda köp aralyk operator bolup biler.
Terminal (“terminal”, “höwesli” hem diýilýär) - elementleri gaýtadan işleýär we akymy bes edýär, şonuň üçin zynjyrda diňe bir terminal operatory bolup biler.

Mysal:

1.List<String> list = new ArrayList<String>();
2.list.add("One");
…
11.list.add("Ten");
12.Stream stream = list.stream();
13.stream.filter(x-> x.toString().length() == 3).forEach(System.out::println);

Bu ýerde näme bolýar:

1 - sanaw döretmek list;
2-11 - synag maglumatlary bilen dolduryň;
12 - obýekt döretmek Stream;
13 - usul filter(süzgüç) - aralyk operator, xsanamak üçin kolleksiýanyň bir elementine deňdir (bolşy ýaly for each) we soňundan -> kolleksiýamyzyň nähili süzülendigini görkezýäris we bu aralyk operator bolansoň, süzülen kolleksiýa hasam dowam edýär , forEachbu bolsa öz gezeginde sanamagyň ahyrky (ahyrky) meňzeşidir ( gysgaça for eachaňlatma : bu bolsa öz gezeginde kolleksiýanyň ähli elementlerinden geçýär we görkezýär)System.out::printlnx-> System.out.println(x))

Möhüm nokatlar:

Terminal operatory çagyrylýança gaýtadan işlemek başlamaz. list.stream().filter(s -> s > 5)(sanawdan ýekeje element hem almaz);
Akymyň mysalyny bir gezekden köp ulanyp bolmaýar = (;

Şonuň üçin her gezek täze bolanda:

list.stream().filter(x-> x.toString().length() == 3).forEach(System.out::println);
list.stream().forEach(x -> System.out.println(x));

Bir akymda çagyrylan köp sanly aralyk operator bolup biler, diňe bir terminal operatory bar:

stream.filter(x-> x.toString().length() == 3).map(x -> x + " - the length of the letters is three").forEach(x -> System.out.println(x));

Indiki, käbir aralyk operatorlara seredeliň:

filter(Predicate predicate)akymy süzýär, diňe şertden geçýän elementleri geçýär (Predicate Java SE 8 bukjasyna goşulan gurlan funksional interfeýsdir, “ hakyky ” we “ ýalanjava.util.function ” bahasyny barlaýar );
map(Function mapper)her elementi üýtgedip, mundan beýläk geçer ýaly bir funksiýa döretmäge mümkinçilik berýär (Funksiýa interfeýsi Function<T,R>T görnüşindäki obýektden R görnüşiniň obýektine geçiş funksiýasyny görkezýär)
flatMap(Function<T, Stream<R>> mapper)- bolşy ýaly map, başlangyç akymyna öwürmek üçin ulanylýar.

Işleýän wagtyňyz, mysal üçin, bir topar akym (massiw, sanaw we ş.m.) bilen olary bir akymy (massiw, sanaw we ş.m.) öwürýär [stream1,stream2,stream3,stream4] => stream:

String[] array = {"Java", "Ruuuuussshhh"};
Stream<String> streamOfArray = Arrays.stream(array);
streamOfArray.map(s->s.split("")) //Convert the word to an array of letters
        .flatMap(Arrays::stream).distinct() //aligns each generated thread into a single thread
        .collect(Collectors.toList()).forEach(System.out::println);

mapSaplaryň sanawyna öwrülende (has takygy sapaklar <Stream>) [stream1,stream2,stream3,stream4] =>Stream.of(stream1,stream2,stream3,stream4):

String[] array = {"Java", "Ruuuuussshhh"};
Stream<String> streamOfArray = Arrays.stream(array);
streamOfArray.map(s->s.split("")) //Convert the word to an array of letters
        .map(Arrays::stream).distinct() //Make the array into a separate thread
        .collect(Collectors.toList()).forEach(System.out::println);

Deňeşdirilende başga bir tapawut map, bir elementi nola, bir ýa-da başga birine öwrüp bilersiňiz. Bir elementi nol elementlere öwürmek üçin gaýdyp gelmeli nullýa-da boş akym. Bir elemente öwürmek üçin bir elementden, meselem, üsti bilen akymy yzyna gaýtarmaly Stream.of(x). Birnäçe elementi yzyna gaýtarmak üçin, bu elementler bilen islendik usul bilen akym döredip bilersiňiz. Birmeňzeş flatMap usuly, ýöne goşa, bitewi we uzyn üçin:

flatMapToDouble (Funksiýa kartasy)
flatMapToInt (Funksiýa kartasy)
flatMapToLong (Funksiýa kartasy)

Deňeşdirmek üçin başga bir mysal, flatMap:

Stream.of(2, 3, 0, 1, 3)
        .flatMapToInt(x -> IntStream.range(0, x))
        .forEach(System.out::print);// 010120012

IntStream.range (0, x) - elementleri 0 (öz içine alýan) -dan x (öz içine almaýar) akymyna çykarýar;

karta:

Stream.of(2, 3, 0, 1, 3)
        .map(x -> IntStream.range(0, x))
        .forEach(System.out::print);//list of streams (streams);

çäk (uzyn maxSize) - akymy elementleriň sany bilen çäklendirýär:
```
stream.limit(5).forEach(x -> System.out.println(x));
```

geçmek (uzyn n) - n elementlerine geçmek:

stream.skip(3).forEach(x -> System.out.println(x));

sortlanan ()
sortlanan (Deňeşdiriji deňeşdiriji) - akymy tertipleýär (TreeMap ýaly sortlamak):
```
stream.sorted().forEach(x -> System.out.println(x));
```
tapawutly () - elementleriň özboluşlylygy üçin akymy barlaýar (elementleriň gaýtalanmagyny aýyrýar);
dropWhile (Predicate predicate) - şerti kanagatlandyrýan elementlerden geçýär (java 9-da peýda boldy, “Predicate <T>” funksional interfeýsi käbir şertleriň ýerine ýetirilendigini ýa-da ýokdugyny barlaýar. Eger ýerine ýetirilen bolsa, hakykat yzyna gaýtarylýar. T parametr hökmünde:
```
Predicate<Integer> isPositive = x -> x > 0;
       System.out.println(isPositive.test(3)); // true
       System.out.println(isPositive.test(-9)); // false
```

Terminal operatorlary:

forEach (Sarp ediji hereketi) - hersine meňzeş (Sarp ediji <T> T görnüşindäki obýektde hiç zat yzyna gaýtarmazdan käbir hereket edýär);
count () - akym elementleriniň sanyny görkezýär:

System.out.println(stream.count());
ýygnamak (Kollektor kollektor) - usul ähli elementleri sanawda, toplumda ýa-da beýleki kolleksiýada ýygnaýar, käbir kriteriýalara görä topar elementleri, hemme zady bir setirde birleşdirýär we ş.m .:
```
List<String> list = Stream.of(“One”, “Two”, “Three”).collect(Collectors.toList());
```
collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)- edil şonuň ýaly, collect(collector)amatlylyk üçin diňe parametrler bozulýar ( suppliertäze zatlar (konteýnerler) üpjün edýär, mysal üçin new ArrayList()konteýnerde accumulatorbir element goşýar, combinerakymyň böleklerini birleşdirýär);
azaltmak (T şahsyýeti, BinaryOperator akkumulýatory) - akymyň ähli elementlerini bir obýekte öwürýär (ähli elementleriň jemini hasaplaň ýa-da iň az elementi tapyň), ilki obýekt identitywe akymyň birinji elementi alynýar, funksiýa ulanylýar netijesi bolýar accumulator. identitySoňra galan elementler üçin hemme zat dowam edýär.
```
int sum = Stream.of(1, 2, 3, 4, 5).reduce(10, (acc, x) -> acc + x);// = 25
```
reduce(BinaryOperator accumulator)- ýokardaky ýaly usul, ýöne ilkinjisi ýok identity, akymyň birinji elementi

Optional min(Comparator comparator)
Goşmaça max (Deňeşdiriji deňeşdiriji) geçen deňeşdirijiniň esasynda iň az / iň ýokary elementi gözleýär;
findFirst()- akymyň birinji elementini çykarýar:
```
Stream.of(1, 2, 3, 4, 9).findFirst();
```
allMatch(Predicate predicate)- akymyň ähli elementleri şerti kanagatlandyrýan bolsa hakyky bolýar. Kesgitli funksiýany çagyrmagyň netijesi ýalňyş bolan haýsydyr bir elemente duş gelse , operator elementleri gözden geçirmegi bes edýär we ýalňyş yzyna gaýdýar :
```
Stream.of(1, 2, 3, 4, 9).allMatch(x -> x <= 7);//false
```
anyMatch(Predicate predicate)- akymyň iň bolmanda bir elementi şerti kanagatlandyrsa, hakykata gaýdyp geler predicate:
```
Stream.of(1, 2, 3, 4, 9).anyMatch(x -> x >= 7);//true
```
noneMatch(Predicate predicate)- akymyň ähli elementlerinden geçip, olaryň hiç biri-de şerti kanagatlandyrmasa, hakykata gaýdyp geler predicate:
```
Stream.of(1, 2, 3, 4, 9).noneMatch(x -> x >= 7);//false
```

Ahyrynda käbir usullara seredip geçmek isleýärin Collectors:

toList()- elementleri ýygnaýar List:

List<Integer> list = Stream.of(99, 2, 3).collect(Collectors.toList());

toSet()- elementleri toplumda ýygnaýar:

Set<Integer> set = Stream.of(99, 2, 3).collect(Collectors.toSet());

counting()- elementleriň sanyny hasaplaýar:

Long count = Stream.of("1", "2", "3", "4").collect(Collectors.counting());

joining()
joining(CharSequence delimiter)

joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)- elementleri bir setire ýygnaýar. Mundan başga-da, bölüji, şeýle hem tutuş yzygiderlilik üçin prefiks we goşulma görkezip bilersiňiz:

String a = Stream.of("s", "u" ,"p", "e", "r").collect(Collectors.joining());
       System.out.println(a); // super

       String b = Stream.of("s", "u", "p", "e", "r").collect(Collectors.joining("-"));
       System.out.println(b); // s-u-p-e-r

       String c = Stream.of("s", "u", "p", "e", "r").collect(Collectors.joining(" -> ", "[ ", " ]"));
       System.out.println(c);  // [ s -> u -> p -> e -> r ]

summingInt(ToIntFunction mapper)
summingLong(ToLongFunction mapper)
summingDouble(ToDoubleFunction mapper)- obýektleri int / uzyn / goşa öwürýän we jemini hasaplaýan kollektor.

Peýdaly baglanyşyklar:

PS: halanýanlar bilen ýuwunmakdan utanmaň ^: ^

Teswirler

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION