Anns a ’phost bhlog seo, tha sinn a’ dol a bhruidhinn air feartan Java 8 Streams agus a ’toirt seachad mòran eisimpleirean còd eadar-dhealaichte.
Bidh Java Streams a ’toirt prògramadh gnìomh gu java agus tha iad a’ faighinn taic a ’tòiseachadh ann an java 8 mar sin ma tha dreach nas sine de java agad, feumaidh tu ùrachadh gu java 8 gus Java Streams a chleachdadh.
Cuid de na buannachdan aig sruthan:
Anns a ’mhòr-chuid de chùisean, tha loidhne-phìoban sruthan a
Tha an stòr a ’dol a shruthladh sruthan de eileamaidean.
Faodar an sruth eileamaidean sin a shìoladh, a sheòrsachadh, no faodar a mhapadh no sreath de dh ’obraichean eile a chuir an sàs anns gach eileamaid.
Aig an deireadh, faodar a chruinneachadh no a lughdachadh no obair crìochnachaidh eile ach chan eil ach aon obair crìochnachaidh air a choileanadh.
Stòr sruth faodaidh iad tighinn bho chruinneachaidhean, liostaichean, seataichean, arrays de int, longs, dùbailte, sreathan, msaa.
Obraichean srutha tha iad eadar-mheadhanach no deireannach:
Am measg cuid de na h-obraichean eadar-mheadhanach tha:
Chan eil ach aon obrachadh crìochnachaidh ceadaichte.
Seo eisimpleirean de lughdachadh gnìomhan:
A-nis chì sinn na bun-bheachdan gu h-àrd ann an eisimpleirean còd.
Is e a ’chiad eisimpleir dìreach sruth integer. Tha sinn a ’dol a chruthachadh sruth integer a’ cleachdadh an IntStream
clas agus a dhleastanas raon a bheir dhuinn raon de integers.
Tha an forEach
is e ar n-obrachadh deireannach. Airson gach rud, tha sinn dìreach airson a chlò-bhualadh.
import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams {
public static void main(String[] args) throws IOException {
IntStream
.range(1, 10)
.forEach(System.out::print);
System.out.println();
} }
Toradh:
123456789
Tha an dàrna eisimpleir a ’cleachdadh sruth integer ach chuir sinn a skip()
an seo, mar sin anns a ’chùis seo, tha sinn a’ dol a leum a ’chiad 5 eileamaidean den t-sruth againn.
Cha bhith seo ach a ’clò-bhualadh eileamaidean 6 tro 9. Bidh sinn cuideachd a’ cleachdadh abairt lambda sìmplidh airson an rud a chlò-bhualadh
import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams {
public static void main(String[] args) throws IOException {
IntStream
.range(1, 10)
.skip(5)
.forEach(x -> System.out.println(x));
System.out.println();
} }
Toradh:
6 7 8 9
An treas eisimpleir, bidh sinn a-rithist a ’cleachdadh an IntStream
gus an sruth de stuthan againn a chruthachadh ge-tà, chuir sinn sin am broinn a println()
aithris mar pharamadair airson an loidhne clò-bhualaidh.
Chan eil sinn a ’dol a chlò-bhualadh ach an t-suim bho raon 1 gu 5 ann am faclan eile, 1 2 3 & 4 cha bhith sinn a’ clò-bhualadh ach suim nan àireamhan sin:
import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams {
public static void main(String[] args) throws IOException {
System.out.println(
IntStream
.range(1, 5)
.sum());
System.out.println();
} }
Toradh:
10
Tha an ath eisimpleir a ’cleachdadh an Stream.of
gnìomh, a tha gu math feumail oir is urrainn dhut integers, luachan puing fleòdraidh no sreathan no eadhon nithean a shruthladh.
San eisimpleir seo, tha sinn dìreach a ’dol a dhèanamh seòrsa aibideil dìreach an uairsin bidh sinn a’ dol a lorg a ’chiad rud a’ cleachdadh an findFirst()
gnìomh. An uairsin, bidh sinn dìreach a ’clò-bhualadh a’ chiad rud air an liosta.
import java.io.IOException; import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) throws IOException {
Stream.of('Ava', 'Aneri', 'Alberto')
.sorted()
.findFirst()
.ifPresent(System.out::println);
} }
Toradh
Alberto
Anns an ath eisimpleir againn, tha sinn a ’dol a shruthladh bho sreath. An uairsin tha sinn a ’dol a sheòrsachadh, a shìoladh agus an uairsin a chlò-bhualadh.
An seo, bidh sinn a ’sìoladh a-mach nithean a-mhàin a thòisicheas le s
.
Bidh sinn a ’cleachdadh abairt lambda a bheir a-steach X
a tha gach ainm agus an uairsin bidh e a ’sgrùdadh dè an fheadhainn a thòisicheas le litir s
agus bheir e seachad iad sin.
An uairsin bidh sinn gan rèiteachadh agus an uairsin airson gach rud a thèid seachad air an t-seòrsa sin tha sinn a ’dol a chlò-bhualadh.
import java.io.IOException; import java.util.Arrays; public class JavaStreams {
public static void main(String[] args) throws IOException {
String[] names = {'Al', 'Ankit', 'Kushal', 'Brent', 'Sarika', 'amanda', 'Hans', 'Shivika', 'Sarah'};
Arrays.stream(names)
.filter(x -> x.startsWith('S'))
.sorted()
.forEach(System.out::println);
} }
Toradh:
Sarah Sarika Shivika
A-nis, leig dhuinn sùil a thoirt air mar as urrainn dhuinn cuibheasachd ceàrnagan de raon int a ghabhail.
An seo, bidh sinn a ’cleachdadh an Arrays.stream()
gnìomh gus na integers a shruthladh agus an uairsin bidh sinn a ’cleachdadh map()
airson gach rud a mhapadh gach integer chun cheàrnag aige.
import java.util.Arrays; public class JavaStreams {
public static void main(String[] args) {
Arrays.stream(new int[] {2, 4, 6, 8, 10})
.map(x -> x * x)
.average()
.ifPresent(System.out::println);
} }
Toradh:
44.0
Thoir fa-near gu bheil e a ’clò-bhualadh dùbailte an àite integer.
San eisimpleir seo, tha sinn a ’dol a shruthladh bho liosta, na rudan sin a shìoladh agus an uairsin a chlò-bhualadh.
Thoir fa-near gu bheil taobh a-staigh an map()
gnìomh, tha sinn a ’dol a thionndadh a h-uile ainm gu litrichean beaga.
import java.util.Arrays; import java.util.List; public class JavaStreams {
public static void main(String[] args) {
List people = Arrays.asList('Al', 'Ankit', 'Brent', 'Sarika', 'amanda', 'Hans', 'Shivika', 'Sarah');
people
.stream()
.map(String::toLowerCase)
.filter(x -> x.startsWith('a'))
.forEach(System.out::println);
} }
Toradh:
al ankit amanda
Chì sinn gu bheil trì ainmean againn a tha a ’tòiseachadh le a
agus tha iad uile ann an litrichean beaga.
Anns an ath eisimpleir againn, tha sinn a ’dol a shruthladh sreathan bho fhaidhle teacsa. Tha sinn a ’dol a sheòrsachadh, a shìoladh agus a chlò-bhualadh.
Gabhamaid ris gu bheil faidhle againn air a bheil bands.txt
le susbaint gu h-ìosal:
Rolling Stones Lady Gaga Jackson Browne Maroon 5 Arijit Singh Elton John John Mayer CCR Eagles Pink Aerosmith Adele Taylor Swift
Tha sinn a ’dol a chleachdadh Files.lines()
gus ar sruth a chruthachadh a tha a ’dol a thoirt dhuinn sruth sreang airson gach loidhne den fhaidhle.
Cho luath ‘s a bhios an sruth againn, bidh sinn a’ dol gan rèiteachadh agus bidh sinn a ’dol a shìoladh a-mach nithean a tha nas motha na 13 caractaran agus an uairsin a’ clò-bhualadh na tha air fhàgail.
Mu dheireadh, feumaidh sinn am faidhle a dhùnadh gus am bi sinn a ’dèanamh bands.close
.
import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) throws IOException {
Stream bands = Files.lines(Paths.get('bands.txt'));
bands
.sorted()
.filter(x -> x.length() > 13)
.forEach(System.out::println);
bands.close();
} }
Toradh:
Jackson Browne Rolling Stones
Gheibh sinn dà chòmhlan aig a bheil barrachd air 13 caractaran.
Mar eisimpleir, cleachdaidh sinn an aon fhaidhle teacsa mar a tha gu h-àrd.
Tha sinn airson rudan anns a bheil na litrichean jit
a shìoladh a-mach, a ’cleachdadh x.contains()
a tha dìreach mar ghnìomh sreang.
A ’cleachdadh an .collect()
bidh sinn a ’cur a h-uile gin le litrichean jit
gu liosta.
Aon uair ‘s gu bheil liosta a-muigh againn, faodaidh sinn an uairsin an forEach
a chleachdadh ghnìomhaiche airson na nithean a chlò-bhualadh.
import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.List; import java.util.stream.Collectors; public class JavaStreams {
public static void main(String[] args) throws IOException {
List bands2 = Files.lines(Paths.get('bands.txt'))
.filter(x -> x.contains('jit'))
.collect(Collectors.toList());
bands2.forEach(x -> System.out.println(x));
} }
Toradh:
Arijit Singh
San eisimpleir seo, bidh sinn a ’sruthadh sreathan bho fhaidhle CSV agus tha sinn a’ dol a chunntadh na sreathan math.
Osbarr tha faidhle againn ris an canar data.txt
leis na leanas:
A,12,3.7 B,17,2.8 C,14,1.9 D,23,2.7 E F,18,3.4
An seo, chan eil dàta aig sreath E, agus mar sin tha sinn airson an tè sin a thoirmeasg bhon t-sruth againn.
Anns a ’chòd a leanas, tha sinn a’ dol a leughadh anns gach sreath agus feumaidh sinn a roinn aig na cromagan gu sreath gus am bi gach sreath na sreath de nithean.
An uairsin bidh sinn a ’cur sìoltachan a-steach gus sreathan anns nach eil trì nithean a shìoladh.
import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) throws IOException {
Stream rows1 = Files.lines(Paths.get('data.txt'));
int rowCount = (int)rows1
.map(x -> x.split(','))
.filter(x -> x.length == 3)
.count();
System.out.println(rowCount + ' rows.');
rows1.close();
} }
Toradh:
5 rows
Tha an eisimpleir seo a ’sealltainn dhut mar a chleachdas tu lughdachadh. Tha sinn a ’dol a lughdachadh gu suim. An seo, tha sruth dùbailte againn a ’cleachdadh an Stream.of()
gnìomh. Tha sinn air trì dùblaidhean a mhìneachadh ann an trì argamaidean eadar-dhealaichte agus tha sinn a ’dol a chleachdadh an gnìomh lughdachadh.
import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) {
double total = Stream.of(7.3, 1.5, 4.8)
.reduce(0.0, (Double a, Double b) -> a + b);
System.out.println('Total = ' + total);
} }
Toradh:
13.600000000000001