தரவு ஸ்ட்ரீம்கள்

1. ஜாவா 8 இல் புதுமைகள்: செயல்பாட்டு நிரலாக்கம்

ஜாவா 8 வெளியீட்டுடன், மொழி செயல்பாட்டு நிரலாக்கத்திற்கான சக்திவாய்ந்த ஆதரவைப் பெற்றது . செயல்பாட்டு நிரலாக்கத்திற்கான நீண்டகாலமாக எதிர்பார்க்கப்பட்ட ஆதரவைப் பெற்றது என்று நீங்கள் கூறலாம். குறியீட்டைப் படிக்க கடினமாக இருந்தாலும், குறியீட்டு முறை வேகமாக மாறியது 🙂

ஜாவாவில் செயல்பாட்டு நிரலாக்கத்தைக் கற்றுக்கொள்வதற்கு முன் , நீங்கள் மூன்று விஷயங்களை நன்கு புரிந்து கொள்ளுமாறு பரிந்துரைக்கிறோம்:

1. OOP, பரம்பரை மற்றும் இடைமுகங்கள் ( ஜாவா கோர் தேடலில் நிலைகள் 1-2 ).
2. ஒரு இடைமுகத்தில் இயல்புநிலை முறை செயலாக்கங்கள் .
3. உள் மற்றும் அநாமதேய வகுப்புகள் .

நல்ல செய்தி என்னவென்றால், ஜாவாவில் செயல்பாட்டு நிரலாக்கத்தின் பல அம்சங்களைப் பயன்படுத்த இதையெல்லாம் நீங்கள் அறிந்திருக்க வேண்டியதில்லை. மோசமான செய்தி என்னவென்றால், அநாமதேய உள் வகுப்புகளைப் பற்றி அறியாமல் எல்லாம் எவ்வாறு ஒழுங்கமைக்கப்பட்டுள்ளது மற்றும் எப்படி எல்லாம் செயல்படுகிறது என்பதைப் புரிந்துகொள்வது கடினமாக இருக்கும்.

வரவிருக்கும் பாடங்களில், ஜாவாவின் செயல்பாட்டு நிரலாக்க அம்சங்களைப் பயன்படுத்துவது எவ்வளவு எளிதானது மற்றும் எளிமையானது என்பதில் கவனம் செலுத்துவோம், அது எவ்வாறு செயல்படுகிறது என்பதைப் பற்றிய ஆழமான புரிதல் இல்லாமல்.

ஜாவாவில் செயல்பாட்டு நிரலாக்கத்தின் அனைத்து நுணுக்கங்களையும் புரிந்து கொள்ள மாதங்கள் ஆகும். சில மணிநேரங்களில் அத்தகைய குறியீட்டைப் படிக்க நீங்கள் கற்றுக்கொள்ளலாம். எனவே சிறியதாக தொடங்க பரிந்துரைக்கிறோம். அது I/O ஸ்ட்ரீம்களுடன் இருந்தாலும்.

2. I/O ஸ்ட்ரீம்கள்: ஸ்ட்ரீம் பைப்லைன்கள்

ஒரு காலத்தில் நீங்கள் I/O ஸ்ட்ரீம்கள்: InputStream, OutputStream, Reader, Writerபோன்றவற்றைப் பற்றி அறிந்து கொண்டது உங்களுக்கு நினைவிருக்கிறதா?

போன்ற தரவு மூலங்களிலிருந்து தரவைப் படிக்கும் ஸ்ட்ரீம் வகுப்புகள் இருந்தன FileInputSteam, மேலும் மற்ற ஸ்ட்ரீம்களில் இருந்து தரவைப் படிக்கும் இடைநிலை தரவு ஸ்ட்ரீம்கள், InputStreamReaderமற்றும் BufferedReader.

இந்த ஸ்ட்ரீம்கள் தரவு செயலாக்க குழாய்களாக ஒழுங்கமைக்கப்படலாம். உதாரணமாக, இது போன்றது:

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>பொருள் உருவாக்கப்படும் போது தரவு நகர்த்தப்படாது . ஸ்ட்ரீம் பைப்லைனைக் கட்டத் தொடங்குவதற்கு ஒரு ஸ்ட்ரீம் பொருள் கிடைத்தது.