జావాలో Arrays.asList() పద్ధతి

చాలా మంది బిగినర్స్ Arrays.asList() పద్ధతి యొక్క కాన్సెప్ట్‌ను డేటా స్ట్రక్చర్ అరేలిస్ట్‌తో గందరగోళానికి గురిచేస్తారు. అవి ఒకే విధంగా కనిపించినప్పటికీ, అమలు విషయానికి వస్తే ఈ రెండూ పూర్తిగా భిన్నంగా ఉంటాయి. ఈ పోస్ట్‌లో, మేము Arrays.asList() పద్ధతి యొక్క ప్రాథమిక ఉపయోగాన్ని కవర్ చేస్తాము మరియు దానికి సంబంధించిన కొన్ని ప్రబలమైన గందరగోళాలను తొలగిస్తాము.

Arrays.asList() ఎందుకు ఉపయోగించబడింది?

మీరు జాబితాగా మార్చాల్సిన శ్రేణిని కలిగి ఉంటే, ఈ ప్రయోజనం కోసం java.util.Arrays ఒక రేపర్ Arrays.asList()ని అందిస్తుంది. సరళంగా చెప్పాలంటే, ఈ పద్ధతి శ్రేణిని పారామీటర్‌గా తీసుకుంటుంది మరియు జాబితాను అందిస్తుంది. సేకరణల ఫ్రేమ్‌వర్క్‌ను ప్రవేశపెట్టడానికి ముందు జావా ప్లాట్‌ఫారమ్ API యొక్క ప్రధాన భాగాలు అభివృద్ధి చేయబడ్డాయి. కాబట్టి అప్పుడప్పుడు, మీరు సాంప్రదాయ శ్రేణులు మరియు మరింత ఆధునిక సేకరణల మధ్య అనువదించవలసి ఉంటుంది. ఈ ఫంక్షన్ సేకరణలు మరియు అర్రే ఆధారిత APIల మధ్య లింక్‌గా పనిచేస్తుంది.

ఉదాహరణ

కింది ఉదాహరణను పరిశీలించండి:

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

public class ArraysAsListDemo {
    public static void main(String[] args) {

	String[] teamMembers = {"Amanda", "Loren", "Keith"};
      // using aslist() method
	List teamList = Arrays.asList(teamMembers);
	System.out.println("List : " + teamList);
		
	HashSet teamHashSet = new HashSet<>(Arrays.asList(teamMembers));
	System.out.println("HashSet : " + teamHashSet);
    }
}

అవుట్‌పుట్:

Arrays.asList() మరియు ArrayList ఎలా విభిన్నంగా ఉంటాయి?

మీరు శ్రేణిలో Arrays.asList() పద్ధతికి కాల్ చేసినప్పుడు, తిరిగి వచ్చిన ఆబ్జెక్ట్ అర్రేలిస్ట్ కాదు ( జాబితా ఇంటర్‌ఫేస్ యొక్క పునర్పరిమాణ శ్రేణి అమలు ). ఇది అంతర్లీన శ్రేణిని యాక్సెస్ చేసే get() మరియు set() పద్ధతులతో కూడిన వీక్షణ వస్తువు. అనుబంధిత ఇటరేటర్ యొక్క యాడ్() లేదా తీసివేయి() వంటి శ్రేణి యొక్క పరిమాణాన్ని మార్చే అన్ని పద్ధతులు మద్దతు లేని ఆపరేషన్ మినహాయింపును విసిరివేస్తాయి . జావా ప్రోగ్రామ్ విజయవంతంగా కంపైల్ చేయబడి, రన్‌టైమ్ మినహాయింపు ఇవ్వడానికి కారణం, స్పష్టంగా, దీని ఫలితంగా “జాబితా” తిరిగి ఇవ్వబడుతుందిArrays.asList() . అన్ని జోడింపు/తొలగింపు కార్యకలాపాలు అనుమతించబడిన చోట. కానీ, అంతర్లీన డేటా నిర్మాణం పునఃపరిమాణం చేయలేని “శ్రేణి” కాబట్టి, రన్ సమయంలో మినహాయింపు ఇవ్వబడుతుంది. ఇది ఎలా ఉంటుందో చూపించే స్నిప్పెట్ ఇక్కడ ఉంది:

import java.util.Arrays;
import java.util.List;
public class ArraysAsListDemo {
   public static void main(String[] args) {
	Integer[] diceRoll = new Integer[6];	
      //using aslist() method
	List diceRollList = Arrays.asList(diceRoll);
	System.out.println(diceRollList);
	
	// using getters and setters to randomly access the list	
	diceRollList.set(5, 6);	
	diceRollList.set(0, 1);	
	System.out.println(diceRollList.get(5));
	System.out.println(diceRollList.get(1));

	System.out.println(diceRollList);
	
	diceRollList.add(7); // Add a new Integer to the list
    }
}

అవుట్‌పుట్:

asList() పద్ధతిని ఉపయోగించడానికి ఉదాహరణలు

జావా SE 5.0 ప్రకారం, asList() పద్ధతిలో ఒక వేరియబుల్ ఆర్గ్యుమెంట్‌లు ఉన్నట్లు ప్రకటించబడింది. శ్రేణిని దాటడానికి బదులుగా, మీరు వ్యక్తిగత అంశాలను కూడా పాస్ చేయవచ్చు. ఉదాహరణకి:

import java.util.Arrays;
import java.util.List;
public class ArraysAsListDemo {
    public static void main(String[] args) {
	List seasons = Arrays.asList("winter", "summer", "spring", "fall");
	List odds = Arrays.asList(1, 3, 5, 7, 9);

	System.out.println(seasons);
	System.out.println(odds);
    }
}

అవుట్‌పుట్:

ముగింపు

Arrays.asList()ని ఉపయోగించడానికి, ఇది మీ స్వంత ప్రయోజనం కోసం కేవలం ఒక రేపర్ పద్ధతి అని మీరు గుర్తుంచుకోవాలి. దీన్ని అర్రేలిస్ట్‌తో కలపవద్దు మరియు అది “జాబితా”ని తిరిగి ఇస్తుందని గుర్తుంచుకోండి. ప్రారంభంలో మీరు జోడింపు/తొలగింపు విధులను నిర్వర్తించడంలో లోపాలను పొందవచ్చు, కానీ స్థిరమైన అభ్యాసం మరియు అవగాహనతో అవన్నీ తొలగిపోతాయి. కాబట్టి మీ IDEని నొక్కండి మరియు గొప్ప అభ్యాస అనుభవాన్ని పొందండి!