ஜாவாவில் ஒரு வரைபடத்தை மீண்டும் செய்வது எப்படி

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

ஜாவாவில் வரைபடம் என்றால் என்ன?

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

நாம் ஏன் ஒரு வரைபடத்தின் மூலம் மீண்டும் மீண்டும் செய்ய வேண்டும்?

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

ஜாவாவில் வரைபடத்தை மீண்டும் செய்ய சில பொதுவான வழிகள் யாவை?

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

1. ForEach Loop முறை
2. மறு செய்கை முறை

கீழே உள்ள இரண்டு முறைகளையும் செயல்படுத்துவதைக் கண்டறியவும்.

Foreach Loop முறையைப் பயன்படுத்துதல்

உதாரணமாக

import java.util.Map;
import java.util.HashMap;

public class ForEachDemo {

	public static void main(String[] args) {

		Map<String, String> businessDays = new HashMap<String, String>();

		// store business days i-e; key/value pairs in the Map
		businessDays.put("1", "Monday");
		businessDays.put("2", "Tuesday");
		businessDays.put("3", "Wednesday");
		businessDays.put("4", "Thursday");
		businessDays.put("5", "Friday");

		// Iterating over the Map.entrySet() using map.forEach
		for (Map.Entry<String, String> entry : businessDays.entrySet()) 
		{
			System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue()); 
		}
	}
}

வெளியீடு

விளக்கம்

இந்த எடுத்துக்காட்டில், வரைபடத்தில் மீண்டும் மீண்டும் செய்ய ஃபோர்ச் லூப்பைப் பயன்படுத்தினோம். ஒவ்வொரு லூப்பைப் பயன்படுத்துவதன் மூலம், வரைபடத்தில் உள்ள தரவின் தானியங்கு "பார்வை", முக்கிய-மதிப்பு ஜோடிகளின் வடிவத்தில் வழங்கும் ஒரு entrySet() ஐப் பெறுகிறோம். ஒவ்வொரு நுழைவுத்தொகுப்பிலும் ஒரு விசை மற்றும் தொடர்புடைய மதிப்புகள் உள்ளன. உங்கள் தேவைகளுக்கு ஏற்ப Map. நுழைவு<விசை, மதிப்பு> அனைத்து முறைகளையும் நீங்கள் பயன்படுத்தலாம் . இங்கே, கன்சோலில் தரவைக் காட்ட getKey() மற்றும் getValue() ஆகியவற்றை மட்டுமே பயன்படுத்தியுள்ளோம் . ஒரு பயிற்சியாக, இந்த கருத்தில் உங்கள் கட்டளையை வலுப்படுத்த மீதமுள்ள முறைகளை நீங்கள் ஆராயலாம்.

இட்டரேட்டர் முறையைப் பயன்படுத்துதல்

உதாரணமாக

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MapIterator {

	public static void main(String[] args) {

		Map<String, String> monthsInAYear = new HashMap<String, String>();

		// store business days i-e; key/value pairs in the Map
		monthsInAYear.put("1", "January");
		monthsInAYear.put("2", "February");
		monthsInAYear.put("3", "March");
		monthsInAYear.put("4", "April");
		monthsInAYear.put("5", "May");
		monthsInAYear.put("6", "June");
		monthsInAYear.put("7", "July");
		monthsInAYear.put("8", "August");
		monthsInAYear.put("9", "September");
		monthsInAYear.put("10", "October");
		monthsInAYear.put("11", "November");
		monthsInAYear.put("12", "December");

		// iterate map / traverse the map using using iterator
		Iterator<Map.Entry<String, String>> iterator = monthsInAYear.entrySet().iterator();

		while (iterator.hasNext()) 
		{
			// check if next entry exists in the map
			Map.Entry<String, String> entry = iterator.next(); 
			System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());

		}
	}
}

வெளியீடு

விளக்கம்

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

மறு செய்கை முறையை விட Foreach loop சிறந்ததா?

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

இரண்டு முறைகளுக்கும் என்ன வித்தியாசம்?

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

எந்த பயண முறையை எப்போது பயன்படுத்த வேண்டும்?

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

• நீங்கள் வரைபடத்தை மாற்ற வேண்டுமானால், இடிரேட்டரைப் பயன்படுத்தவும் .
• உங்களிடம் உள்ளமைக்கப்பட்ட சுழல்கள் இருந்தால் (சிக்கலைத் தவிர்க்க) ஒவ்வொரு லூப்பைப் பயன்படுத்தவும் .

முடிவுரை

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