జావాలో మ్యాప్‌ను ఎలా పునరావృతం చేయాలి

ఈ పోస్ట్‌లో, మేము జావాలో మ్యాప్‌ను పునరావృతం చేయడానికి వివిధ మార్గాలను నేర్చుకుంటాము. దాని యొక్క కొన్ని సాధారణ మార్గాలు మరియు ఉదాహరణల సహాయంతో వాటిని ఎలా ఉపయోగించాలి. ప్రారంభించడానికి ముందు, మీరు జావాలో ఇంటర్‌ఫేస్‌లు మరియు మ్యాప్‌లను అర్థం చేసుకున్నారని మేము అనుకుంటాము. అయితే, ఇక్కడ మీ కోసం శీఘ్ర రీక్యాప్ ఉంది.

జావాలో మ్యాప్ అంటే ఏమిటి?

దీనికి చాలా వివరణలు ఉన్నాయి, కానీ దానిని ఈ విధంగా ఉంచుదాం. "మ్యాప్ అనేది జావాలో ఇంటర్‌ఫేస్, ఇది కీ-విలువ జతల రూపంలో డేటాను నిల్వ చేయడానికి ఉపయోగించబడుతుంది." మ్యాప్‌లు దేనికి ఉపయోగించబడుతున్నాయని మీరు ఆలోచిస్తున్నట్లయితే? లేదా అవి ఎప్పుడు అవసరమవుతాయి? మేము డేటాను కీ-విలువ జతలలో నిల్వ చేయవలసి వచ్చినప్పుడు నిజ జీవితంలో చాలా సందర్భాలు ఉన్నాయి. ఉదాహరణకు, నిఘంటువులోని ఒకే అక్షరానికి సంబంధించిన అన్ని పదాలను జావాలో మ్యాప్ రూపంలో నిల్వ చేయవచ్చు. అంతేకాకుండా, దీన్ని బాగా అర్థం చేసుకోవడానికి మీరు ఈ క్రింది ఉదాహరణలను చూడవచ్చు.

మనం మ్యాప్ ద్వారా ఎందుకు పునరావృతం చేయాలి?

డేటాను యాక్సెస్ చేయడం, సవరించడం లేదా తీసివేయడం కోసం మేము మ్యాప్‌లో ప్రయాణించడం లేదా మళ్లించడం అవసరం. మనకు ఉన్న కొన్ని ఎంపికలను అన్వేషిద్దాం.

జావాలో మ్యాప్‌ని పునరావృతం చేయడానికి కొన్ని సాధారణ మార్గాలు ఏమిటి?

మ్యాప్‌లో ప్రయాణించడానికి అనేక మార్గాలు ఉన్నప్పటికీ. అయితే, మేము అత్యంత సమర్థవంతమైన మరియు సరళమైన మార్గాలపై దృష్టి పెడతాము.

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()); 
		}
	}
}

అవుట్‌పుట్

వివరణ

ఈ ఉదాహరణలో మేము మ్యాప్‌పై మళ్లించడానికి foreach లూప్‌ని ఉపయోగించాము. ప్రతి లూప్‌ని ఉపయోగించడం ద్వారా, కీ-విలువ జతల రూపంలో మ్యాప్‌లోని డేటా యొక్క స్వయంచాలక “వీక్షణ”ని అందించే ఎంట్రీసెట్() ని మేము పొందుతాము. ప్రతి ఎంట్రీసెట్ కీ మరియు సంబంధిత విలువలను కలిగి ఉంటుంది. మీ అవసరాలకు అనుగుణంగా మీరు మ్యాప్‌లోని అన్ని పద్ధతులను ఎక్కడ ఉపయోగించవచ్చు.ఎంట్రీ <కీ, విలువ> . ఇక్కడ, కన్సోల్‌లో డేటాను ప్రదర్శించడానికి మేము 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 లూప్ మెరుగైనదా?

మ్యాప్ మీ కోసం పని చేసినంత కాలం మీరు దాని ప్రయాణం కోసం ఏ పద్ధతిని ఉపయోగిస్తున్నారనేది పట్టింపు లేదు. పనితీరు పరంగా, ప్రతి లూప్ మరియు ఇటరేటర్లు రెండూ ఒకే సమయ సంక్లిష్టతను కలిగి ఉంటాయి . కాబట్టి ఏదీ మరొకదాని కంటే మెరుగైనది కాదు, మీరు ఏమి ఉపయోగించాలి మరియు ఎప్పుడు ఉపయోగించాలి అనే దానిపై ఆధారపడి ఉంటుంది.

రెండు పద్ధతుల మధ్య తేడా ఏమిటి?

ప్రతి లూప్ మ్యాప్‌లోని డేటాను నవీకరించడానికి/సవరించడానికి అనుమతించదు. దీనికి విరుద్ధంగా, మీరు ఇటరేటర్లను ఉపయోగించి డేటాను సులభంగా సవరించవచ్చు. మ్యాప్‌లోని డేటాను సవరించడానికి/తీసివేయడానికి అమలును అందించడం ద్వారా ఇటరేటర్‌ల తరగతి మీకు సౌకర్యాన్ని అందిస్తుంది. దీనికి విరుద్ధంగా, మీరు ప్రతి లూప్‌ని ఉపయోగించి మ్యాప్ డేటాను సవరించడానికి/తొలగించడానికి ప్రయత్నిస్తే, అది ConcurrentModificationException ని విసిరివేస్తుంది . దీనికి కారణం ఏమిటంటే, ప్రతి లూప్ వినియోగదారుకు బహిర్గతం కాకుండా పరోక్షంగా ఒక ఇటరేటర్‌ను సృష్టిస్తుంది. అందువల్ల, మీకు ఏ డేటాను సవరించడానికి లేదా తొలగించడానికి యాక్సెస్ లేదు.

ఏ ట్రావెర్సల్ పద్ధతిని ఉపయోగించాలి మరియు ఎప్పుడు?

మీ మ్యాప్‌ని మళ్లించడానికి ప్రతి కోసం లేదా ఇటరేటర్‌లను ఉపయోగించాలా అని మీకు ఖచ్చితంగా తెలియకపోతే, మీరు ఈ క్రింది సూచనలను తీసుకోవచ్చు.

• మీరు మ్యాప్‌ని సవరించాల్సి వస్తే ఇటరేటర్‌ని ఉపయోగించండి .
• మీరు సమూహ లూప్‌లను కలిగి ఉంటే (క్లిష్టతను నివారించడానికి) ప్రతి లూప్‌ని ఉపయోగించండి .

ముగింపు

పోస్ట్ ముగిసే సమయానికి, మీరు జావాలో మ్యాప్‌ను ఎలా పునరావృతం చేయాలో నేర్చుకున్నారని మేము ఆశిస్తున్నాము. మీరు వీటిని అభ్యసించమని మరియు ట్రావర్సల్ యొక్క ఇతర పద్ధతులను కూడా ప్రయత్నించమని ప్రోత్సహించబడ్డారు. మీరు ఇరుక్కుపోయినట్లు అనిపించినప్పుడల్లా వెనుకకు వెళ్లడానికి లేదా ప్రశ్నలను పోస్ట్ చేయడానికి సంకోచించకండి. అప్పటి వరకు, హ్యాపీ లెర్నింగ్!