Oideachadh Sruth Java 8 le eisimpleirean còd

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.



Carson a chleachdas tu sruthan Java?

Cuid de na buannachdan aig sruthan:


  • Nì sruthan thu prògramadair java nas èifeachdaiche (chì thu le glè bheag de loidhnichean còd gun urrainn dhut tòrr a choileanadh le bhith a ’cleachdadh sruthan).
  • Bidh iad a ’dèanamh feum mòr de dh’ abairtean lambda a tha nan seòrsa de ghnìomhan cugallach.
  • Tha ParallelStreams a ’comasachadh obrachaidhean ioma-snàthainn airson stòran-dàta mòra gu math furasta.


Pìob-loidhne sruthan

Anns a ’mhòr-chuid de chùisean, tha loidhne-phìoban sruthan a

  • stòr (far a bheil an dàta agad a ’sruthadh a-mach)
  • air a leantainn le neoni no barrachd obair eadar-mheadhanach
  • agus aon obrachadh ceann-uidhe

Sruth Java - Filter, Map, Lùghdaich


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

Stòr sruth faodaidh iad tighinn bho chruinneachaidhean, liostaichean, seataichean, arrays de int, longs, dùbailte, sreathan, msaa.


Obraichean Sruth

Obraichean srutha tha iad eadar-mheadhanach no deireannach:

  • Obraichean eadar-mheadhanach leithid sìoltachan, mapa, no seòrsa a thilleadh sruthan gus an urrainn dhuinn iomadh obair eadar-mheadhanach a cheangal.
  • Obraichean crìochnachaidh gheibh iad sruth agus faodaidh iad an dàrna cuid tilleadh falamh no faodaidh iad toradh neo-shruth a thilleadh mar lughdachadh, m.e. lughdaich nithean gu liosta.

Obraichean eadar-mheadhanach

  • Tha cead aig neoni no barrachd obair eadar-mheadhanach.
  • Cùisean òrdugh; airson seataichean dàta mòra: sìoladh an toiseach an uairsin a sheòrsachadh no a mhapadh.
  • Airson stòran-dàta glè mhòr bidh sinn ParallelStream gus iomadh snàithlean a chomasachadh.

Am measg cuid de na h-obraichean eadar-mheadhanach tha:

  • anyMatch ()
  • àraid ()
  • criathrag ()
  • lorgFirst ()
  • flatmap ()
  • mapa ()
  • sgiob ()
  • air a sheòrsachadh ()

Obraichean crìochnachaidh

Chan eil ach aon obrachadh crìochnachaidh ceadaichte.

  • tha forEach a ’buntainn an aon ghnìomh ri gach eileamaid mar eisimpleir clò-bhuail gach eileamaid.
  • cruinnichidh sàbhaladh na h-eileamaidean gu lèir ann an cruinneachadh no liosta no sreath.
  • bidh a h-uile roghainn eile a ’lughdachadh an t-sruth gu aon eileamaid geàrr-chunntas.

Seo eisimpleirean de lughdachadh gnìomhan:


  • cunnt ()
  • max ()
  • min ()
  • lughdaich ()


Eisimpleirean de chòd sruthan Java

A-nis chì sinn na bun-bheachdan gu h-àrd ann an eisimpleirean còd.

Sruth integer

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

Sruth integer le Skip

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

Sruth iomlan le suim

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

Sruth.of

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

Sruth bho Array, a sheòrsachadh, a shìoladh agus a chlò-bhualadh

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

Cuibheasachd Array Integer

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.

Sruth bhon Liosta, sìoladh agus clò-bhualadh

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.

Sreathan sruthan bho fhaidhle teacsa, a sheòrsachadh, a shìoladh agus a chlò-bhualadh

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.

Sruth sreathan bhon fhaidhle teacsa agus sàbhail gu Liosta

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

Sreathan sruthan bho fhaidhle CSV agus cunntadh

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

Lùghdachadh - suim

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