Java Collections: તમે ચૂકી જતા છુપાયેલા સાધનો
મોટાભાગના ડેવલપર્સ દરરોજ Java collections નો ઉપયોગ એક જ રીતે કરે છે. તેઓ ArrayLists અને HashSets નો ઉપયોગ કરે છે. પરંતુ તમે એવા સાધનો ચૂકી રહ્યા હોઈ શકો છો જે તમારા કોડને વધુ ઝડપી અને સુરક્ષિત બનાવે છે.
તમારા કોડને સુધારવા માટે અહીં ત્રણ ચોક્કસ સાધનો છે.
- Arrays.asList એ સાચું List નથી
જ્યારે તમે Arrays.asList(array) નો ઉપયોગ કરો છો, ત્યારે તમને એક નિશ્ચિત-કદ (fixed-size) ની લિસ્ટ મળે છે. તે સીધું તમારા મૂળ એરે (array) સાથે જોડાયેલું હોય છે.
- જો તમે એરે બદલો છો, તો લિસ્ટ પણ બદલાઈ જાય છે.
- જો તમે આઇટમ્સ ઉમેરવાનો અથવા દૂર કરવાનો પ્રયાસ કરો છો, તો તમારો કોડ એરર સાથે ક્રેશ થઈ જશે.
આને સુધારવા માટે, તેને નવા ArrayList માં લપેટી (wrap) દો:
List<String> list = new ArrayList<>(Arrays.asList(array));
આ એક સાચું, સ્વતંત્ર લિસ્ટ બનાવે છે જેને તમે મોડિફાય કરી શકો છો.
- પરફોર્મન્સ માટે EnumSet નો ઉપયોગ કરો
શું તમે enums ને HashSet માં સ્ટોર કરો છો? તે બિનજરૂરી ઓવરહેડ (overhead) પેદા કરે છે. HashSets હેશ ટેબલ્સ અને ઓબ્જેક્ટ હેડર્સનો ઉપયોગ કરે છે.
તેના બદલે EnumSet નો ઉપયોગ કરો. તે આંતરિક રીતે bit vector નો ઉપયોગ કરે છે. તે અત્યંત ઝડપી છે અને લગભગ બિલકુલ મેમરીનો ઉપયોગ કરતું નથી. તે પ્લેયર પાવર્સ અથવા સેટિંગ્સ જેવી ફ્લેગ-આધારિત સિસ્ટમ્સ માટે પરફેક્ટ છે.
- તે type-safe છે.
- તે HashSet કરતા ઘણું ઝડપી છે.
- તે તમારા માટે bitwise ઓપરેશન્સ હેન્ડલ કરે છે.
- કેશ (caches) માટે ConcurrentHashMap.computeIfAbsent નો ઉપયોગ કરો
જો તમે કેશ બનાવો છો, તો તમે ઘણીવાર મલ્ટીપલ થ્રેડ્સને એક જ વેલ્યુ ગણતરી કરતા રોકવા માટે જટિલ કોડ લખો છો. આને double-checked locking કહેવામાં આવે છે. તે વાંચવામાં અઘરું છે અને તેમાં ભૂલ થવાની શક્યતા વધુ છે.
તેના બદલે, માત્ર એક લાઇનનો ઉપયોગ કરો:
cache.computeIfAbsent(key, this::expensiveCalculation);
આ મેથડ atomic છે. તે સુનિશ્ચિત કરે છે કે ગણતરી ફક્ત એક જ વાર ચાલે, ભલે ઘણા બધા થ્રેડ્સ એક જ સમયે સમાન કી (key) માટે પૂછતા હોય. તે બગ્સ ઘટાડે છે અને તમારા હેતુને સ્પષ્ટ બનાવે છે.
આ સાધનો શા માટે મહત્વના છે:
- અનુમાનિત પરફોર્મન્સ: તમે છુપાયેલા મેમરી ખર્ચથી બચી શકો છો.
- ઓછા બગ્સ: તમે મલ્ટી-થ્રેડેડ કોડમાં race conditions સામે લડવાનું બંધ કરો છો.
- વધુ સ્પષ્ટ કોડ: અન્ય ડેવલપર્સ તમારા ડિઝાઇનને તરત જ સમજી શકે છે.
ફ્રેમવર્ક સામે લડવાનું બંધ કરો. વધુ સ્લીમ (leaner) અને સુરક્ષિત કોડ લખવા માટે તેનો ઉપયોગ કરવાનું શરૂ કરો.