స్ట్రీమ్‌లతో పని చేయడం, పార్ట్ 2

1. డేటా మార్పిడి

తరగతికి Stream<T>డేటాను ఒక రకం నుండి మరొక రకానికి మార్చడానికి మిమ్మల్ని అనుమతించే పద్ధతి కూడా ఉంది. ఈ పద్ధతి map().

ఇది స్ట్రీమ్‌ను కూడా అందిస్తుంది, కానీ వేరే రకం అంశాలతో. ఈ map()పద్ధతి ఒక డేటా రకాన్ని మరొకదానికి మార్చే ఫంక్షన్‌ని మెథడ్ ఆర్గ్యుమెంట్‌గా తీసుకుంటుంది.

ఉదాహరణలు:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream2 = stream.map((x) -> String.valueOf(x));

పద్ధతికి పంపబడిన ఫంక్షన్ ఆర్గ్యుమెంట్ map()ఒక సంఖ్యను తీసుకుంటుంది xమరియు దాని స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుంది. మార్గం ద్వారా, మీరు ఈ కోడ్‌ను మరింత సంక్షిప్తంగా వ్రాయవచ్చు:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream2 = stream.map(String::valueOf);

స్ట్రింగ్‌ను సంఖ్యగా మారుస్తోంది

అదేవిధంగా, మీరు స్ట్రింగ్‌ను సంఖ్యగా మార్చడానికి కోడ్‌ను వ్రాయవచ్చు - ఇది కూడా సంక్లిష్టంగా లేదు:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream2 = stream.map(String::valueOf);
Stream<Integer> stream3 = stream2.map(Integer::parseInt);

స్ట్రింగ్‌ను 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 );

మేము సేకరణను సృష్టించాము మరియు దానిని 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;
  }
});

మనం ఏమి చెప్పగలం? తనిఖీ చేయబడిన మినహాయింపును ఉపయోగించే ముందు మీరు ఒకటికి రెండుసార్లు ఆలోచించాలి . మరియు వాటిని కన్స్ట్రక్టర్‌లో ఉపయోగించే ముందు మూడుసార్లు ఆలోచించండి.