1. డేటా మార్పిడి
తరగతికి Stream<T>
డేటాను ఒక రకం నుండి మరొక రకానికి మార్చడానికి మిమ్మల్ని అనుమతించే పద్ధతి కూడా ఉంది. ఈ పద్ధతి map()
.
ఇది స్ట్రీమ్ను కూడా అందిస్తుంది, కానీ వేరే రకం అంశాలతో. ఈ map()
పద్ధతి ఒక డేటా రకాన్ని మరొకదానికి మార్చే ఫంక్షన్ని మెథడ్ ఆర్గ్యుమెంట్గా తీసుకుంటుంది.
ఉదాహరణలు:
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream2 = stream.map((x) -> String.valueOf(x));
Integer
స్ట్రీమ్ను String
స్ట్రీమ్గా మారుస్తోంది
పద్ధతికి పంపబడిన ఫంక్షన్ ఆర్గ్యుమెంట్ map()
ఒక సంఖ్యను తీసుకుంటుంది x
మరియు దాని స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుంది. మార్గం ద్వారా, మీరు ఈ కోడ్ను మరింత సంక్షిప్తంగా వ్రాయవచ్చు:
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream2 = stream.map(String::valueOf);
Integer
స్ట్రీమ్ను String
స్ట్రీమ్గా మారుస్తోంది
స్ట్రింగ్ను సంఖ్యగా మారుస్తోంది
అదేవిధంగా, మీరు స్ట్రింగ్ను సంఖ్యగా మార్చడానికి కోడ్ను వ్రాయవచ్చు - ఇది కూడా సంక్లిష్టంగా లేదు:
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream2 = stream.map(String::valueOf);
Stream<Integer> stream3 = stream2.map(Integer::parseInt);
String
స్ట్రీమ్ను Integer
స్ట్రీమ్గా మారుస్తోంది
స్ట్రింగ్ను aకి మార్చడంURI
డేటా మార్పిడి కార్యకలాపాలు వనరు- మరియు సమయం ఎక్కువగా ఉంటాయి. మేము స్ట్రింగ్ల సేకరణను URI ఆబ్జెక్ట్లుగా మార్చాలనుకుంటున్నాము. దీన్ని చేయడం చాలా సులభం, ఎందుకంటే URI కన్స్ట్రక్టర్ స్ట్రింగ్ను ఆర్గ్యుమెంట్గా తీసుకుంటుంది.
ArrayList<String> list = new ArrayList<String>();
list.add("https://google.com");
list.add("https://linkedin.com");
list.add("https://yandex.com");
Stream<URI> stream = list.stream().map( URI::new );
String
స్ట్రీమ్ను URI
స్ట్రీమ్గా మారుస్తోంది
మేము సేకరణను సృష్టించాము మరియు దానిని 3 వెబ్ చిరునామాలతో నింపాము. అప్పుడు మేము Stream<String>
సేకరణ నుండి ఒక వస్తువును పొందాము మరియు ఆ ప్రవాహం నుండి మనకు ఒక Stream<URI>
వస్తువు వచ్చింది. మేము ప్రతి స్ట్రింగ్ను URIకి మార్చడానికి ఉపయోగించే పద్ధతికి సూచనగా మ్యాప్ పద్ధతిని ఆమోదించాము.
String
ఈ పద్ధతి (కన్స్ట్రక్టర్) తప్పనిసరిగా వాదనగా తీసుకోవాలి . అంతా పర్ఫెక్ట్గా అనిపించింది...
2. మినహాయింపులు
పైన ఉన్న కోడ్ పని చేస్తుందని మేము ఆశించవచ్చు, కానీ అది జరగదు — ప్రోగ్రామ్ కంపైల్ చేయదు. మరియు మేము ఎక్కడో పొరపాటు చేసినందుకు కాదు, కానీ జావా సృష్టికర్తలు గందరగోళానికి గురయ్యారు.
ఒకప్పుడు, క్లాస్ కన్స్ట్రక్టర్కి తనిఖీ చేయబడిన మినహాయింపు ( URISyntaxException
) ని జోడించాలనే అద్భుతమైన ఆలోచన వారికి ఉంది URI
! మరియు అటువంటి మినహాయింపులు తప్పనిసరిగా ఒక లో చుట్టబడి ఉండాలి try-catch
.
కాబట్టి మా కోడ్ యొక్క చివరి పంక్తి ఇలా కనిపిస్తుంది:
Stream<URI> stream = list.stream().map(str ->
{
try
{
return new URI(str);
}
catch (URISyntaxException e)
{
e.printStackTrace();
return null;
}
});
మనం ఏమి చెప్పగలం? తనిఖీ చేయబడిన మినహాయింపును ఉపయోగించే ముందు మీరు ఒకటికి రెండుసార్లు ఆలోచించాలి . మరియు వాటిని కన్స్ట్రక్టర్లో ఉపయోగించే ముందు మూడుసార్లు ఆలోచించండి.
GO TO FULL VERSION