డేటా స్ట్రీమ్‌లు

1. జావా 8లో ఆవిష్కరణలు: ఫంక్షనల్ ప్రోగ్రామింగ్

జావా 8 విడుదలతో, భాష ఫంక్షనల్ ప్రోగ్రామింగ్‌కు శక్తివంతమైన మద్దతును పొందింది . ఫంక్షనల్ ప్రోగ్రామింగ్ కోసం ఇది చాలా కాలంగా ఎదురుచూస్తున్న మద్దతును పొందిందని కూడా మీరు చెప్పవచ్చు. కోడ్ చదవడం చాలా కష్టంగా ఉన్నప్పటికీ, కోడింగ్ వేగంగా మారింది 🙂

జావాలో ఫంక్షనల్ ప్రోగ్రామింగ్ నేర్చుకునే ముందు , మీరు మూడు విషయాలను బాగా అర్థం చేసుకోవాలని మేము సిఫార్సు చేస్తున్నాము:

1. OOP, వారసత్వం మరియు ఇంటర్‌ఫేస్‌లు ( జావా కోర్ క్వెస్ట్‌లో 1-2 స్థాయిలు ).
2. ఇంటర్‌ఫేస్‌లో డిఫాల్ట్ పద్ధతి అమలులు .
3. అంతర్గత మరియు అనామక తరగతులు .

శుభవార్త ఏమిటంటే, జావాలో ఫంక్షనల్ ప్రోగ్రామింగ్ యొక్క అనేక లక్షణాలను ఉపయోగించడానికి మీరు ఇవన్నీ తెలుసుకోవలసిన అవసరం లేదు. చెడు వార్త ఏమిటంటే, అనామక అంతర్గత తరగతుల గురించి తెలియకుండా ప్రతిదీ ఎలా అమర్చబడిందో మరియు ప్రతిదీ ఎలా పని చేస్తుందో సరిగ్గా అర్థం చేసుకోవడం కష్టం.

రాబోయే పాఠాలలో, జావా ఫంక్షనల్ ప్రోగ్రామింగ్ ఫీచర్‌లను ఉపయోగించడం ఎంత సులభమో మరియు అది ఎలా పని చేస్తుందనే దానిపై లోతైన అవగాహన లేకుండా మేము దృష్టి పెడతాము.

జావాలో ఫంక్షనల్ ప్రోగ్రామింగ్ యొక్క అన్ని సూక్ష్మ నైపుణ్యాలను అర్థం చేసుకోవడానికి నెలల సమయం పడుతుంది. మీరు అలాంటి కోడ్‌ని కొన్ని గంటల్లో చదవడం నేర్చుకోవచ్చు. కాబట్టి చిన్నగా ప్రారంభించాలని మేము సూచిస్తున్నాము. ఇది I/O స్ట్రీమ్‌లతో ఉన్నప్పటికీ.

2. I/O స్ట్రీమ్‌లు: స్ట్రీమ్ పైప్‌లైన్‌లు

ఒకప్పుడు మీరు I/O స్ట్రీమ్‌ల గురించి నేర్చుకున్నారని మీకు గుర్తుందా: InputStream, OutputStream, Reader, Writerమొదలైనవి?

వంటి డేటా మూలాల నుండి డేటాను చదివే స్ట్రీమ్ తరగతులు ఉన్నాయి మరియు ఇతర FileInputSteamస్ట్రీమ్‌ల నుండి డేటాను చదివే ఇంటర్మీడియట్ డేటా స్ట్రీమ్‌లు ఉన్నాయి .InputStreamReaderBufferedReader

ఈ స్ట్రీమ్‌లను డేటా ప్రాసెసింగ్ పైప్‌లైన్‌లుగా నిర్వహించవచ్చు. ఉదాహరణకు, ఇలా:

FileInputStream input = new FileInputStream("c:\\readme.txt");
InputStreamReader reader = new InputStreamReader(input);
BufferedReader buff = new BufferedReader(reader);

String text = buff.readLine();

కోడ్ యొక్క మొదటి కొన్ని పంక్తులలో, మేము కేవలం వస్తువుల గొలుసును నిర్మిస్తున్నామని గమనించడం ముఖ్యం Stream. డేటా ఇంకా పైప్‌లైన్ ద్వారా పాస్ కాలేదు.

కానీ మేము పద్ధతిని పిలిచిన వెంటనే buff.readLine(), ఈ క్రింది విధంగా జరుగుతుంది:

1. వస్తువు వస్తువుపై పద్ధతిని BufferedReaderపిలుస్తుందిread()InputStreamReader
2. వస్తువు వస్తువుపై పద్ధతిని InputStreamReaderపిలుస్తుందిread()FileInputStream
3. ఆబ్జెక్ట్ ఫైల్ నుండిFileInputStream డేటాను చదవడం ప్రారంభిస్తుంది

read()మరో మాటలో చెప్పాలంటే, మేము లేదా వంటి పద్ధతులను కాల్ చేయడం ప్రారంభించే వరకు స్ట్రీమ్ పైప్‌లైన్‌లో డేటా యొక్క కదలిక ఉండదు readLine(). స్ట్రీమ్ పైప్‌లైన్ నిర్మాణం దాని ద్వారా డేటాను నడపదు. స్ట్రీమ్‌లు డేటాను నిల్వ చేయవు. వారు ఇతరుల నుండి మాత్రమే చదువుతారు.

సేకరణలు మరియు ప్రసారాలు

జావా 8తో ప్రారంభించి, సేకరణల నుండి డేటాను చదవడానికి స్ట్రీమ్‌ను పొందడం సాధ్యమైంది (మరియు వాటి నుండి మాత్రమే కాదు). కానీ ఇది అత్యంత ఆసక్తికరమైన విషయం కాదు. డేటా స్ట్రీమ్‌ల సంక్లిష్ట గొలుసులను సులభంగా మరియు సరళంగా నిర్మించడం నిజానికి సాధ్యమైంది. మరియు అలా చేయడం ద్వారా, గతంలో 5-10 పంక్తులు తీసుకున్న కోడ్ ఇప్పుడు 1-2 లైన్లలో వ్రాయబడుతుంది.

స్ట్రింగ్‌ల జాబితాలో పొడవైన స్ట్రింగ్‌ను కనుగొనే ఉదాహరణ:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String max = list.stream().max((s1, s2)-> s1.length()-s2.length()).get();

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
Stream<String> stream = list.stream();
Optional<String> optional = stream.max((s1, s2)-> s1.length()-s2.length());
String max = optional.get();

3. Streamఇంటర్ఫేస్

స్ట్రీమ్‌ల కోసం జావా 8 యొక్క పొడిగించిన మద్దతు ఇంటర్‌ఫేస్‌ని ఉపయోగించి అమలు చేయబడుతుంది Stream<T>, ఇక్కడ Tస్ట్రీమ్‌లో పాస్ చేయబడే డేటా రకాన్ని సూచించే టైప్ పారామీటర్ ఉంటుంది. మరో మాటలో చెప్పాలంటే, స్ట్రీమ్ అది పాస్ చేసే డేటా రకం నుండి పూర్తిగా స్వతంత్రంగా ఉంటుంది.

సేకరణ నుండి స్ట్రీమ్ ఆబ్జెక్ట్‌ని పొందడానికి , దాని పద్ధతికి కాల్ చేయండి stream(). కోడ్ దాదాపు ఇలా కనిపిస్తుంది:

Stream<Type> name = collection.stream();

ఈ సందర్భంలో, సేకరణ స్ట్రీమ్ యొక్క డేటా మూలంగా పరిగణించబడుతుంది మరియు Stream<Type>ఆబ్జెక్ట్ అనేది డేటా స్ట్రీమ్ రూపంలో సేకరణ నుండి డేటాను పొందేందుకు ఒక సాధనంగా ఉంటుంది.

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
Stream<String> stream = list.stream();

మార్గం ద్వారా, మీరు సేకరణల నుండి మాత్రమే కాకుండా శ్రేణుల నుండి కూడా స్ట్రీమ్‌ను పొందవచ్చు . దీన్ని చేయడానికి, మీరు పద్ధతిని ఉపయోగించాలి . ఉదాహరణకి:Arrays.stream()

Stream<Type> name = Arrays.stream(array);

ఈ సందర్భంలో, శ్రేణి అనే స్ట్రీమ్ కోసం డేటా మూలంగా పరిగణించబడుతుంది name.

Integer[] array = {1, 2, 3};
Stream<Integer> stream = Arrays.stream(array);

Stream<Type>ఆబ్జెక్ట్ సృష్టించబడినప్పుడు డేటా తరలించబడదు . స్ట్రీమ్ పైప్‌లైన్‌ను నిర్మించడం ప్రారంభించడానికి మేము కేవలం స్ట్రీమ్ ఆబ్జెక్ట్‌ని పొందాము.