ஸ்ட்ரீம்களுடன் பணிபுரிதல், பகுதி 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;
  }
});

நாம் என்ன சொல்ல முடியும்? சரிபார்க்கப்பட்ட விதிவிலக்கைப் பயன்படுத்துவதற்கு முன்பு நீங்கள் இருமுறை சிந்திக்க வேண்டும் . ஒரு கன்ஸ்ட்ரக்டரில் அவற்றைப் பயன்படுத்துவதற்கு முன் மூன்று முறை யோசிக்கவும்.