ઉકેલાયેલ: મૂલ્યો સાથે સૂચિ પ્રારંભ કરો

ચોક્કસ, ચાલો લેખ લખવાનું શરૂ કરીએ.

મૂલ્યો સાથે સૂચિ શરૂ કરી રહ્યા છીએ Java માં વિકાસકર્તાઓ માટે સામાન્ય રીતે જરૂરી કામગીરી છે. તે ઘણી વખત જોવા મળે છે કે જાવા પ્રોગ્રામરોને યાદી બનાવવા, તેમાં મૂલ્યો ઉમેરવા અને પછી યાદીમાં કામગીરી કરવા જેવી કામગીરી સાથે વ્યવહાર કરવો પડે છે. જો યોગ્ય રીતે હાથ ધરવામાં ન આવે તો આ પ્રક્રિયા કંટાળાજનક બની શકે છે. તેથી, મૂલ્યો સાથે સૂચિઓ શરૂ કરવાની કાર્યક્ષમ રીતોની સમજ પ્રોગ્રામિંગ કાર્યોને નોંધપાત્ર રીતે સુવ્યવસ્થિત કરી શકે છે.

આ લેખ વિવિધ પદ્ધતિઓ અને પુસ્તકાલયોનો ઉપયોગ કરીને જાવામાં મૂલ્યો સાથે સૂચિઓ કેવી રીતે શરૂ કરવી તેની સમજ પ્રદાન કરશે.

ડાયરેક્ટ ઇનિશિયલાઇઝેશન

મૂલ્યો સાથે સૂચિને પ્રારંભ કરવાની સૌથી સીધી રીત એ છે કે ઉપયોગ કરીને ઉમેરો() યાદી વર્ગ પદ્ધતિ. આ પદ્ધતિ સૂચિના અંતે એક તત્વ ઉમેરે છે.

ચાલો એક ઉદાહરણ ધ્યાનમાં લઈએ:

List<String> list = new ArrayList<>();

list.add("Element1");
list.add("Element2");
list.add("Element3");

નવી સૂચિમાં હવે ત્રણ તત્વો Element1, Element2 અને Element3 છે.

જો કે, જ્યારે મોટી સંખ્યામાં તત્વો ઉમેરવાના હોય ત્યારે પદ્ધતિ કાર્યક્ષમ નથી. વધુ કાર્યક્ષમ ઉકેલો નીચે ચર્ચા કરવામાં આવી છે.

Arrays.asList() નો ઉપયોગ કરીને

જાવા આપે છે એરેઝ તેના થી વર્ગ java.util પેકેજ વર્ગમાં એરેની હેરફેર માટે વિવિધ પદ્ધતિઓનો સમાવેશ થાય છે. આ asList() આ વર્ગની પદ્ધતિ સ્થિર છે અને ઉલ્લેખિત એરે દ્વારા સમર્થિત નિશ્ચિત કદની સૂચિ આપે છે.

ચાલો એક ઉદાહરણથી સમજીએ:

List<String> list = Arrays.asList("Element1", "Element2", "Element3");

પદ્ધતિ સરળ અને કાર્યક્ષમ છે, પરંતુ પાછી આપેલી સૂચિ અપરિવર્તનશીલ છે. જો તમે સૂચિમાંથી ઘટકો ઉમેરવા અથવા દૂર કરવાનો પ્રયાસ કરશો, તો તે java.lang.UnsupportedOperationException અપવાદ ફેંકશે.

સંગ્રહોનો ઉપયોગ કરીને

સંગ્રહો નો વર્ગ java.util પેકેજ એ એક ઉપયોગિતા વર્ગ છે જેમાં ક્લાસના ઑબ્જેક્ટ પર ઑપરેશન કરવા માટેની સ્થિર પદ્ધતિઓ છે જે કલેક્શન ફ્રેમવર્કનો અમલ કરે છે. એક પદ્ધતિ છે ncopies(int n, object obj) જે ઉલ્લેખિત ઑબ્જેક્ટની ચોક્કસ સંખ્યાની નકલો ધરાવતી અપરિવર્તનશીલ સૂચિ પરત કરે છે.

પદ્ધતિના ઉપયોગનું ઉદાહરણ:

List<String> list = Collections.nCopies(3, "Element");

આ પદ્ધતિમાં, સૂચિના તમામ ઘટકોને ઉલ્લેખિત ઑબ્જેક્ટ પર પ્રારંભ કરવામાં આવે છે, આમ સૂચિના તમામ ઘટકો સમાન છે.

Java 8 સ્ટ્રીમનો ઉપયોગ કરવો

જાવા 8 એ એક નવું રજૂ કર્યું સ્ટ્રીમ API જેનો ઉપયોગ કોડની કેટલીક લીટીઓમાં મૂલ્યો સાથે સૂચિને પ્રારંભ કરવા માટે થઈ શકે છે.

List<String> list = Stream.of("Element1", "Element2", "Element3")
                          .collect(Collectors.toList());

આ કોડમાં, Stream.of() પદ્ધતિ અનુક્રમિક ક્રમાંકિત સ્ટ્રીમ આપે છે જેના ઘટકો ઉલ્લેખિત મૂલ્યો છે. કલેક્ટ() મેથડ એ ટર્મિનલ ઑપરેશન છે જે પરિણામને વિવિધ ડેટા સ્ટ્રક્ચર્સમાં એકત્રિત કરે છે અને અહીં તે સ્ટ્રીમ એલિમેન્ટ્સને સૂચિમાં એકત્રિત કરે છે.

ઉપસંહાર

તેથી જાવામાં મૂલ્યો સાથે સૂચિ શરૂ કરવાની આ કેટલીક પદ્ધતિઓ છે. Java માં યાદીઓ સાથે કામ કરતી વખતે, વપરાશકર્તાઓ પાસે તેમના સંદર્ભની જરૂરિયાતોને આધારે વિવિધ વિકલ્પો હોય છે. દાખલા તરીકે, સમાન તત્વની ઘણી નકલો સાથે નિશ્ચિત-કદની સૂચિ બનાવવા માટે, સંગ્રહ વર્ગની ncopies પદ્ધતિનો ઉપયોગ કરી શકાય છે. એરે સાથે કામ કરતી વખતે, Arrays.asList() હાથમાં આવે છે. Java 8 ની સુવિધાઓનો લાભ લેવા માંગતા વપરાશકર્તાઓ માટે, સ્ટ્રીમ API સૂચિ કામગીરીને સુવ્યવસ્થિત કરવા માટે સંક્ષિપ્ત સિન્ટેક્સ પ્રદાન કરે છે. હંમેશની જેમ, યોગ્ય પદ્ધતિ પસંદ કરવી એ પ્રોજેક્ટની ચોક્કસ જરૂરિયાતો અને પ્રતિબંધો પર ઘણો આધાર રાખે છે.