Students frequently turn to Computer Class 12 GSEB Solutions and GSEB Computer Textbook Solutions Class 12 Chapter 9 ઍરે અને સ્પ્રિંગનો ઉપયોગ for practice and self-assessment.
GSEB Computer Textbook Solutions Class 12 Chapter 9 ઍરે અને સ્પ્રિંગનો ઉપયોગ
પ્રશ્ન 1.
ઍરે વિશે ઉદાહરણ આપી સમજાવો.
ઉત્તરઃ
ઍરેનો પરિચય (Introduction to Array)
- મૂળભૂત પ્રકારના ચલ(Variable)માં એક સમયે ફક્ત એક જ માહિતી રાખી શકાય છે. દા. ત., int marks; આ પ્રકારના ચલને અદિશ ચલ કે સ્કેલર વેરિએબલ (Scalar variables) કહે છે.
- જે ચલનો ઉપયોગ એક કરતાં વધારે ડેટા કિંમતોના સમૂહનો સંગ્રહ કરવા માટે થાય છે, તેને કમ્પોઝિટ (Composite) ડેટાપ્રકાર કહે છે. દા. ત., અરે (Array) અને સ્પ્રિંગ (String).
- ઍરે એ એક જ પ્રકારના ઘટકોના સંગ્રહને રજૂ કરે છે. ઍરે સદિશ (Vector), શ્રેણિક (Matrix) અને અન્ય બહુ-પરિમાણીય (Multi-dimensional) માહિતી રજૂ કરવા માટે ઉપયોગી છે.
- જ્યારે સમાન પ્રકારના અનેક ઘટકો ઉપર એકસમાન કાર્ય કરવાનું હોય, ત્યારે ઍરે ઉપયોગી બને છે.
- ઍરેના તમામ ઘટકો મેમરીમાં એકસાથે લગોલગ સંગ્રાહેલા હોય છે. ઍરેના દરેક ઘટકને ઍરે વેરિએબલ સાથે સંકળાયેલા સૂચક સ્થાનાંક (Index position) વડે ઓળખવામાં આવે છે.
ઍરે બનાવવા માટેનાં પગલાં :
ઍરે બનાવવા માટે નીચે દર્શાવેલ બે પગલાં અનુસરવામાં આવે છે :
- ઍરે ઑબ્જેક્ટ ઘોષિત કરવો.
- ઍરે ઑબ્જેક્ટની રચના કરવી.
ઍરે ઑબ્જેક્ટ બે રીતથી બનાવી શકાય છે :
- new પ્રક્રિયક વાપરી અને તેનું કદ જણાવીને
દા. ત., int marks [ ] = new int [5]; - સીધેસીધા ઍરેના ઘટકોને પ્રારંભિક કિંમત આપીને દા. ત., int marks [ ] = {90, 60, 70, 50, 40};
પ્રશ્ન 2.
1-D અને 2-Dઍરે વચ્ચેનો તફાવત જણાવો.
ઉત્તરઃ
એક-પરિમાણીય ઍરે (1-D Array)
- એક અથવા વધારે અદિશ ચલ(Scalar variables)ના સમૂહને એક-પરિમાણીય ઍરે (1-D Array) અથવા વેક્ટર (Vector) કહે છે.
ઉદાહરણ તરીકે marks [5] ઍરે છે.
અહીં આપણે marksl, marks2, marks3, marks4, marks5ને અલગ અલગ ઘોષિત કરવાને બદલે marks [5] ઍરે તરીકે ઘોષિત કરી શકીએ છીએ. - 1-D ઍરે ઘોષિત કરવા માટે ચોરસ કૌંસની જોડી ‘[ ]’ ઍરેના નામ પછી અથવા ડેટાપ્રકા૨ પછી આપણે વાપરીએ છીએ.
- ઍરે ઘોષિત કરવાની વાક્યરચના (Syntax) :
<data type> <array name>[ ];
ઉદાહરણ :
int marks [5]; //declare array object marks=new int [5] //create array object
અરે ઘોષિત કરવાની વૈકલ્પિક રીત (Optional Syntax) :
int marks [ ]=new int[5];
અથવા
int[ ] marks = new int[5]; - અહીં ઍરેનું નામ ‘marks’ છે.
- તે પાંચ સંખ્યાનો સંગ્રહ જ્યાં થશે, તે મેમરી સ્થાનાંકનો નિર્દેશ કરે છે.
- int ડેટાપ્રકારની પૂર્ણાંક સંખ્યાના સંગ્રહ માટે 4 બાઇટ વપરાય છે. આથી ‘marks’ ઍરે માટે સળંગ 5 × 4 = 20 બાઇટની જરૂર પડે છે.
- આકૃતિ માં દર્શાવ્યા પ્રમાણે ઍરેના નામ પછી મોટા કૌંસ [ ]’ની અંદર ઇન્ડેક્સ (Index) અથવા સબસ્ક્રિપ્ટ- (Subscript)નો ઉપયોગ થાય છે. સબસ્ક્રિપ્ટ ઍરેમાં ઘટકનું સ્થાન દર્શાવે છે. દા. ત., marks [3]
- ઇન્ડેક્સ(સબસ્ક્રિપ્ટ)ની કિંમત શૂન્ય (0)થી શરૂ થાય છે.
- આકૃતિ માં ઍરે marksની ઇન્ડેક્સ કિંમત 0 થી 4 છે. અહીં marks[0] ઍરેના પ્રથમ ઘટકનો નિર્દેશ કરે છે અને marks[4] એ છેલ્લા ઘટકનો નિર્દેશ કરે છે.
- ઍરે જાવામાં એક ઑબ્જેક્ટ હોવાથી ઍરેનું નામ પણ એક રેફરન્સ ચલ (Reference variable) છે. તે મેમરીના એ સ્થાનાંકનો રેફરન્સ ધરાવે છે, જ્યાં ઍરેના ઘટકોનો સંગ્રહ થયેલો છે.
- આકૃતિ માં જાવા પ્રોગ્રામમાં ઍરેના ઉપયોગનું ઉદાહરણ દર્શાવેલ છે.
નોંધ : ઍરે ઘોષિત કરતા સમયે 1-D ઍરેના ઘટકોની પ્રારંભિક કિંમતો છગડિયા કોંસ ‘{ }’માં અલ્પવિરામ વડે અલગ પાડેલી કિંમતો વડે આપી શકાય છે.
ઉદાહરણ : int marks[ ]={90, 70, 80}; અથવા int[ ] marks={90, 70, 80};
- આકૃતિ માં આપેલો જાવા કોડ ઍરે બનાવવા માટે તેમજ તેના ઘટકોની પ્રારંભિક કિંમતો આપવા માટેની અલગ અલગ રીત દર્શાવે છે.
- અહીં, display ( ) ક્લાસ મેથડને static ઘોષિત કરેલ છે. તેથી ક્લાસના કોઈ પણ ઑબ્જેક્ટ વિના તેને વાપરી શકાય છે.
- જાવામાં આપણે જ્યારે ઍરે ઘોષિત કરીએ, તે સમયે પરિમાણનું માપ (Size) અને તેના ઘટકોની પ્રારંભિક કિંમતો (Initial values) બંને એકસાથે આપી શકતા નથી.
- ઍરેના ઘટકની કિંમત બદલવા માટે અન્ય ચલની જેમ આપણે ઘટકચલને અસાઇનમેન્ટ વિધાનમાં ડાબી બાજુએ વાપરી શકીએ છીએ. દા. ત., marks [2] = 80;
પ્રયોગ
હેતુ : ઍરે અને લૂપનો ઉપયોગ કરીને 10 સંખ્યાની સરેરાશ શોધવાનો પ્રોગ્રામ બનાવવો.
આકૃતિ માં સંખ્યાની સરેરાશ (મધ્યક) શોધવાનો પ્રોગ્રામ દર્શાવેલ છે.
- જાવામાં ઍરેને Arrays classની મેથડ(Methods)નો ઉપયોગ કરવાની સગવડ આપે છે. જાવામાં java.util.Arrays ક્લાસની વિવિધ static methodsનો ઉપયોગ કરી આપણે ઍરે ઉપર વિવિધ પ્રક્રિયાઓ જેવી કે બે ઍરેની સરખામણી કરવી, એક ઍરેના બધા ઘટકોની અન્ય ઍરેમાં નકલ કરવી, ઍરેમાંથી કોઈ ચોક્કસ ઘટક શોધવો, ઍરેના ઘટકોને ક્રમાનુસાર ગોઠવવા વગેરે કરી શકીએ છીએ.
- આકૃતિ માં દર્શાવેલું કોડ લિસ્ટિંગ અને તેનો આઉટપુટ java.util.Array ક્લાસની sort() અને fill ( ) મેથડનો ઉપયોગ કઈ રીતે કરી શકાય છે, તે દર્શાવે છે.
- સમગ્ર ઍરે કે તેના અમુક ભાગને ક્રમાનુસાર ગોઠવવા માટે sort ( ) મેથડનો ઉપયોગ થાય છે.
- જ્યારે sort મેથડના આર્ગ્યુમેન્ટ (Argument) તરીકે ફક્ત ઍરે આપવામાં આવે, ત્યારે સમગ્ર ઍરેને સૉર્ટ કરવામાં આવે છે.
- જ્યારે sort મેથડના આર્ગ્યુમેન્ટ (Argument) તરીકે આરંભ સ્થાન અને અંતિમ સ્થાન આપવામાં આવે છે, ત્યારે આરંભ સ્થાનના ઘટકથી અંતિમ સ્થાનથી આગળના ઘટક સુધીના આંશિક ઍરેને સૉર્ટ કરવામાં આવશે.
દા. ત., java.util.Array.sort (list, 1, 5)
આ આદેશ આપવાથી list[1]થી list[5 – 1] સુધીના ઍરેના ઘટકોને સૉર્ટ કરવામાં આવશે. - સમગ્ર કે આંશિક ઍરેને કોઈ ચોક્કસ કિંમતથી ભરવા માટે ‘fill’ મેથડનો ઉપયોગ થાય છે.
- જ્યારે fill મેથડ ઍરે અને કિંમત એમ બે આર્ગ્યુમેન્ટ સાથે ઇન્વોક કરવામાં આવે, ત્યારે ઍરેના બધા ઘટકોમાં જણાવેલી કિંમત ભરવામાં આવશે.
- જ્યારે fill મેથડ ઍરે, આરંભ સ્થાન, અંતિમ સ્થાન અને કિંમત એમ ચાર આર્ગ્યુમેન્ટ સાથે ઇન્વોક કરવામાં આવે, ત્યારે તે આરંભ સ્થાનથી અંતિમ સ્થાનના ઘટકથી આગળના ઘટક સુધી આપેલી કિંમત ભરવામાં આવશે.
- દા. ત., fill (list 7) આદેશથી ઍરેના બધા ઘટકો કિંમત 7 વડે ભરવામાં આવે છે.
fill (list 2, 6, 7) આદેશથી ઍરેના ઘટક list[2]થી list [6 – 1] માં કિંમત 7 ભરવામાં આવે છે. - આપેલી કિંમતવાળો ઘટક ઍરેમાં શોધવા માટે ઍરે ક્લાસમાં binarySearch ( ) મેથડનો ઉપયોગ થાય છે.
- આકૃતિ માં સુરેખ શોધ (Linear Search) પદ્ધતિથી આપેલી કિંમતવાળો ઘટક શોધવા માટેનું કોડ લિસ્ટિંગ દર્શાવેલ છે.
નોંધ : સુરેખ શોધ પદ્ધતિમાં ઍરેના એક પછી એક ઘટકોને આપેલી કિંમત સાથે ક્રમાનુસાર સરખાવવામાં આવે છે. જો ઍરેમાં આપેલી કિંમતવાળો ઘટક મળે, તો તેનું સૂચક સ્થાન (Index position) પરત કરવામાં આવે છે, નહિ તો – 1 કિંમત પરત કરે છે.
2-D ઍરે (2-D Array)
- દ્વિ-પરિમાણીય (2-D) ઍરે હાર અને સ્તંભ સ્વરૂપે કોષ્ટકીય માહિતીનો સંગ્રહ કરવા માટે વપરાય છે.
- આકૃતિ માં પાંચ હાર અને ત્રણ સ્તંભવાળી કોષ્ટકીય ગોઠવણ દર્શાવેલ છે, જેમાં પાંચ વિદ્યાર્થીના ત્રણ કસોટીના ગુણ દર્શાવવામાં આવ્યા છે. આવી માહિતીનો સંગ્રહ કરવા 2-D ઍરેનો ઉપયોગ થાય છે.
| Student | Test1 | Test2 | Test3 |
| 1 | 50 | 60 | 70 |
| 2 | 35 | 30 | 50 |
| 3 | 70 | 75 | 80 |
| 4 | 80 | 85 | 90 |
| 5 | 40 | 50 | 55 |
[આકૃતિ : 2-Dઍરેની કોષ્ટકીય રજૂઆત ]
- જાવામાં 2-D ઍરે ઘોષિત કરવા માટે ઍરેનું નામ અને મોટા કૌંસની બે જોડી ‘[ ][ ]’નો ઉપયોગ થાય છે. અહીં પ્રથમ કૌંસ હાર (Row) અને બીજો કૌંસ સ્તંભ- (Column)ના કદનો ઉલ્લેખ કરે છે.
- ઉદાહરણ : int marks[ ][ ]=new int[5][3]
અહીં, 2-D ઍરેમાં 5 હાર અને 3 સ્તંભનું કોષ્ટક બનશે. જે મેમરીમાં સળંગ 5 × 3 = 15 પૂર્ણાંક કિંમતોનો સંગ્રહ કરશે અને 15 × 4 byte = 60 byte જગ્યા મેમરીમાં રોકશે. [કારણ કે int ડેટાપ્રકાર 4 બાઇટ મેમરીમાં જગ્યા રોકે છે.] - જાવામાં 2-D ઍરે બનાવવા માટે આપણે ઍરેનો ઍરે બનાવવો પડે.
- marks[5][3]માં એક 5 ઘટકોનો 1-D ઍરે બને છે અને આકૃતિ માં દર્શાવ્યા પ્રમાણે આ દરેક ઘટક એ 3 પૂર્ણાંક સંખ્યાનો એક 1-D ઍરે ઑબ્જેક્ટ છે.
- 2-D ઍરેને ઘોષિત કરવાની અને પ્રારંભિક કિંમતો આપવાની રીત 1-D ઍરે જેવી જ છે. અહીં દરેક હારને પ્રારંભિક કિંમતો આપવા માટે છડિયા કોંસ { }ની અંદર અલ્પવિરામથી અલગ પાડેલી તેના ઘટકોની કિંમતો આપવામાં આવે છે.
- આકૃતિ માં 2-D ઍરેને ઘોષિત કરવાની વિવિધ રીતોનું કોડ લિસ્ટિંગ દર્શાવેલ છે. આકૃતિ માં આ કોડનો આઉટપુટ દર્શાવેલ છે.
- જાવામાં 2-D ઍરેની હારમાં ગમે તેટલી સંખ્યામાં સ્તંભ હોઈ શકે છે. આકૃતિ માં કમ્પ્યૂટર પ્રોગ્રામિંગની પાંચ ભાષાઓનાં નામનો સંગ્રહ કરવા માટે અક્ષરોના 2-D ઍરેનો ઉપયોગ દર્શાવ્યો છે.
- અહીં દરેક હારનું કદ અલગ અલગ છે અને આ કદ 1-D ઍરેની ‘length’ નામની પ્રૉપર્ટી વડે જાણી શકાય છે.
- આકૃતિ માં અલગ અલગ માપના 2-D ઍરેનો ઉપયોગ કરતું કોડ લિસ્ટિંગ દર્શાવેલ છે.
નોંધ : 2-D ઍરેમાં ઘટકોની સંખ્યા એ તેમાં રહેલી હારની સંખ્યા છે અને દરેક હાર એ 1-D ઍરે છે. એટલે કે length પ્રૉપર્ટી જ્યારે ફક્ત ઍરેના નામ સાથે વાપરવામાં આવે, ત્યારે તે તેના પ્રથમ પરિમાણનું કદ પરત કરે છે.
ઉદાહરણ : Sales[5][12] ઍરે માટે sales.length એ 5 કિંમત પરત કરશે.
- આકૃતિ માં આપણે નામનો સંગ્રહ કરવા માટે બાઇટનો 2-D ઍરે વાપર્યો છે.
- અહીં, Char પ્રકારના ડેટાને byte પ્રકારમાં પરિવર્તિત કરેલ છે અને નામના અક્ષરોને તેની અનુરૂપ ASCII કિંમત આપવામાં આવી છે.
ઍરે બાબતે યાદ રાખવાના મુદ્દા :
- ઍરે એકસમાન પ્રકારના ડેટાનો સંગ્રહ કરે છે.
- ઍરેના ઘટકોને તેના દરેક પરિમાણના ઇન્ડેક્સને મોટા કૌંસ [ ]’માં આપીને વાપરી શકાય છે.
- ઍરેના ઇન્ડેક્સની કિંમત શૂન્ય ‘0’થી થાય છે.
- ઍરેના ઘટકો પર વિવિધ કાર્યો કરવા જાવામાં java.util.Array ક્લાસની વિવિધ static methods ઉપલબ્ધ હોય છે.
- પરિમાણનું કદ જાણવા માટે length’ ઍટ્રિબ્યૂટનો ઉપયોગ થાય છે.
- ઍરેને તેની પ્રારંભિક કિંમતો આપ્યા વિના ઘોષિત કરવાથી ઍરે ઑબ્જેક્ટ બનતો નથી.
પ્રશ્ન 3.
નીચે જણાવેલા ક્લાસનો ઉપયોગ સમજાવો :
(a) String
ઉત્તરઃ
સ્ટ્રિંગ ક્લાસ મેથડ (String Class Methods)
- જાવામાં સ્ટ્રિંગ ક્લાસ મેથડ પૂરી પાડવામાં આવે છે, જેના દ્વારા નીચે મુજબનાં કાર્યો કરી શકાય છે :
- બે સ્ટ્રિંગની તુલના કરવી.
- સ્ટ્રિંગની લંબાઈ મેળવવી.
- બે સ્પ્રિંગને જોડવી.
- સ્વિંગમાંથી આંશિક સ્ટ્રિંગ (Sub string) મેળવવી.
- સ્ટ્રિંગને પરાવર્તિત કરવી.
- સ્ટ્રિંગનું વિભાજન કરવું.
- અક્ષર અથવા અક્ષરસમૂહને સ્વિંગમાં શોધવા વગેરે.
- આકૃતિ માં દર્શાવેલ પ્રોગ્રામ સ્ટ્રિંગ અથવા સબસ્ટ્રિંગની સરખામણી કરવાની વિવિધ રીત દર્શાવે છે.
- કોષ્ટક 2માં સ્ટ્રિંગની તુલના કરવા માટેની વિવિધ મેથડનું વર્ણન અને વાક્યરચના દર્શાવી છે.
કોષ્ટક 2 : સ્પ્રિંગની તુલના માટે સ્પ્રિંગ ક્લાસની વિવિધ મેથડ
| મેથડ | વર્ણન |
| boolean equals (String str) | મેથડ કૉલ કરતી સ્પ્રિંગ અને પ્રાચલ str (ઑબ્જેક્ટ) સરખાં હોય, તો true પરત કરે છે. |
| boolean equalsIgnoreCase (String str) | મેથડ કૉલ કરતી સ્ટ્રિંગ અને પ્રાચલ strઑબ્જેક્ટના અક્ષરોના કેસ (Case) (કૅપિટલ અને બીજી એબીસીડી)ની અવગણના કરીને તુલના કરે છે. જો બંને સરખાં હોય, તો true પરત કરે છે. (Case insensitive) |
| int compareTo (String str) | જો મેથડ કૉલ કરનાર સ્ટ્રિંગ ઑબ્જેક્ટ પ્રાચલ strની તુલનાએ સમાન હોય, મોટી હોય અથવા નાની હોય, તો અનુક્રમે 0, >0, <0 પૂર્ણાંક સંખ્યા પરત કરે છે. |
| int compareToIgnoreCase (String str) | CompareTo મેથડ પ્રમાણે જ પરંતુ case પ્રત્યે અસંવેદનશીલ |
- સ્ટ્રિંગ ક્લાસમાં આવેલ મેથડ દ્વારા કરી શકાતા અલગ અલગ કાર્ય કોષ્ટક 3માં દર્શાવેલ છે.
કોષ્ટક 3 : સ્ટ્રિંગ ક્લાસની અન્ય મેથડ
| મેથડ | કાર્ય |
| int length( ) | મેથડ કૉલ કરતી સ્વિંગ ઑબ્જેક્ટમાં રહેલા અક્ષરોની સંખ્યા પરત કરે છે. |
| char indexAt (int index) | મેથડ કૉલ કરતી સ્વિંગ ઑબ્જેક્ટમાં પ્રાચલ ઇન્ડેક્સ સ્થાને આવેલા અક્ષરને પરત કરે છે. ઇન્ડેક્સ શૂન્યથી ગણાય છે. |
| byte[ ] getBytes( ) | મેથડ કૉલ કરતી સ્ટ્રિંગના અક્ષરોને byte ઍરેમાં પરત કરે છે. |
| void getChars (int fromIndx, int toIndx, char target[ ], int targetIndx) |
મેથડ કૉલ કરતી સ્વિંગ ઑબ્જેક્ટના fromIndx સ્થાનથી toIndx-1 સ્થાન સુધીના અક્ષરોની લક્ષ્ય ઍરેમાં targetIndx સ્થાન પછી નકલ કરે છે. |
| String concat(String str) | મેથડ કૉલ કરતી સ્ટ્રિંગના અંતમાં પ્રાચલ strના અક્ષરોને ઉમેરીને સ્વિંગ ઑબ્જેક્ટ પરત કરે છે. |
| String toLowerCase( ) | મેથડ કૉલ કરતી સ્ટ્રિંગના બધા જ અક્ષરોને સ્મૉલ અક્ષરોમાં બનાવીને સ્વિંગ પરત કરે છે. |
| String toUpperCase( ) | મેથડ કૉલ કરતી સ્ટ્રિંગના બધા જ અક્ષરોને કૅપિટલ અક્ષરમાં પિરવર્તિત કરીને સ્ટ્રિંગ પરત કરે છે. |
- આકૃતિ માં સ્ટ્રિંગને પરિવર્તિત કરતી મેથડનો ઉપયોગ દર્શાવતો જાવા પ્રોગ્રામ દર્શાવેલ છે.
નોંધ : ઍરે ચલ માટે length એ ઍટ્રિબ્યૂટ કે પ્રૉપર્ટી છે. જ્યારે સ્વિંગ ઑબ્જેક્ટ માટે length એ મેથડ છે. આથી સ્વિંગ ઑબ્જેક્ટ સાથે length મેથડ વાપરતા સમયે( ) કૌંસનો ઉપયોગ કરવો જરૂરી છે.
- આકૃતિ માં સ્ટ્રિંગને ઉલટાવવા માટેનું કોડિંગ દર્શાવેલ છે.
- અહીં આપણે વપરાશકર્તા વ્યાખ્યાયિત (User defined) મેથડ reverseStr લખી છે, જે નીચે જણાવેલાં પગલાં પ્રમાણે સ્ટ્રિંગને ઉલટાવે છે :
- સ્ટ્રિંગ ક્લાસની length( ) મેથડ વાપરીને સ્ટ્રિંગમાં રહેલા અક્ષરોની સંખ્યા નક્કી કરવામાં આવે છે.
- સ્ટ્રિંગ ક્લાસની getBytes ( ) મેથડના ઉપયોગથી સ્વિંગને byte ઍરેમાં પરિવર્તિત કરવામાં આવે છે.
- byte ઍરેમાં ડાબી બાજુના અડધા ઘટકોની (ડાબી બાજુથી જમણી બાજુ તરફ) જમણી બાજુના અડધા ઘટકો (જમણી બાજુથી ડાબી બાજુ તરફ) સાથે અદલાબદલી કરવામાં આવે છે.
- કન્સ્ટ્રક્ટર વાપરીને byte ઍરેમાંથી સ્વિંગ ઑબ્જેક્ટ બનાવી તેને પરત કરવામાં આવે છે.
(b) Date
ઉત્તરઃ
Date ક્લાસ (Date Class)
- જાવા લાઇબ્રેરીમાં java.util નામના પૅકેજમાં String ક્લાસ, Arrays ક્લાસની જેમ જ Date ક્લાસ પણ ઉપલબ્ધ હોય છે.
- Date ક્લાસ તારીખ અને સમય બંનેનો સમાવેશ કરે છે અને મિલિસેકન્ડ સુધીની ચોકસાઈ સહિત કિંમત જણાવે છે.
- આકૃતિ માં Date ક્લાસનો ઉપયોગ સમજાવતું કોડ લિસ્ટિંગ દર્શાવેલ છે.
- કોષ્ટક 4માં Date ક્લાસની કેટલીક મેથડ અને વર્ણન દર્શાવેલ છે.
કોષ્ટક 4 : Date ક્લાસની વિવિધ મેથડ
| મેથડ | વર્ણન |
| Date( ) | સિસ્ટમના તત્કાલીન સમયનો ઉપયોગ કરીને Date ઑબ્જેક્ટ બનાવે છે. |
| Date(long elapsedTime) | જાન્યુઆરી 1, 1970 GMT થી પ્રાચલમાં આપેલા સમય વચ્ચેનો સમયગાળો મિલિસેકન્ડમાં ગણીને Date ઑબ્જેક્ટ બનાવે છે. |
| StringtoString( ) | Date ઑબ્જેક્ટના તારીખ અને સમયને સ્વિંગમાં રજૂ કરી તે સ્પ્રિંગ પરત કરે છે. |
| long getTime( ) | જાન્યુઆરી 1, 1970 GMT થી અત્યાર સુધીની મિલિસેકન્ડ પરત કરે છે. |
| VoidsetTime (long elapsedTime) | પ્રાચલમાં આપેલા વિતેલા સમયનો ઉપયોગ કરી નવી તારીખ અને સમય સેટ કરે છે. |
(c) Calendar
ઉત્તરઃ
Calendar ક્લાસ (Calendar Class)
- Date ક્લાસની જેમ Calendar ક્લાસ પણ java.util પૅકેજમાં આપવામાં આવ્યો છે.
- Calendar ક્લાસ વર્ષ, માસ, તારીખ, કલાક, મિનિટ અને સેકન્ડ જેવી કૅલેન્ડરની વિગતવાર માહિતી મેળવવા માટે વાપરી શકાય છે.
- આકૃતિ માં Calendar ક્લાસનો ઉપયોગ કરતો પ્રોગ્રામ અને તેનું આઉટપુટ દર્શાવ્યું છે. અહીં તારીખ અને સમયના વિવિધ ઘટક પ્રદર્શિત કરવા માટે વપરાશકર્તાએ વ્યાખ્યાયિત (User defined) display( ) ક્લાસ મેથડનો ઉપયોગ કર્યો છે.
- આકૃતિ માં દર્શાવેલ પ્રોગ્રામમાં get મેથડ વાપરીને Calendar ક્લાસના ક્ષેત્ર અચલ(Field constants)ની કિંમત મેળવવામાં આવી છે. આ જ રીતે set મેથડ વાપરીને Calendar ક્લાસના ક્ષેત્ર અચલની કિંમત આપણે સેટ કરી શકીએ છીએ.
- ઉદાહરણ તરીકે, calendar.set(calendar.DATE,20) મેથડ કૉલનો અમલ કરતાં મહિનાની તારીખ 20 સેટ થશે.
- કોષ્ટક 5માં Calendar ક્લાસમાં વ્યાખ્યાયિત પૂર્ણાંક સંખ્યાવાળા અચલોની યાદી આપેલી છે. આ અચલોને અર્થપૂર્ણ અને સ્વયંસ્પષ્ટ નામો આપવામાં આવેલા છે.
કોષ્ટક 5 : Calendar ક્લાસમાં વ્યાખ્યાયિત અચલ
| અચલ | વર્ણન |
| YEAR | કૅલેન્ડરનું વર્ષ |
| MONTH | કૅલેન્ડરનો મહિનો (જાન્યુઆરી માટે 0 અને ડિસેમ્બર માટે 11) |
| DATE | મહિનાનો દિવસ |
| DAY_OF_MONTH | મહિનાનો દિવસ (DATE સમાન) |
| HOUR | 12 કલાકની સંકેતલિપિ પ્રમાણે કલાક |
| HOUR_OF_DAY | 24 કલાકની સંકેતલિપિ પ્રમાણે કલાક |
| MINUTE | મિનિટ |
| SECOND | સેકન્ડ |
| AM_PM | AM માટે 0 અને PM માટે 1 |
| DAY_OF_WEEK | અઠવાડિયામાં દિવસનો ક્રમ (રવિવાર માટે 1 અને શનિવા૨ માટે 7) |
| WEEK_OF_MONTH | મહિનામાં અઠવાડિયાનો ક્રમ |
| WEEK_OF_YEAR | વર્ષમાં અઠવાડિયાનો ક્રમ |
| DAY_OF_YEAR | વર્ષમાં દિવસનો ક્રમ (પ્રથમ દિવસ માટે 1) |
Computer Class 12 GSEB Notes Chapter 9 ઍરે અને સ્પ્રિંગનો ઉપયોગ
સ્ટ્રિંગ (String)
- સ્ટ્રિંગ એટલે અક્ષરોની શ્રેણી એટલે કે અક્ષરોના 1-D ઍરેને સ્પ્રિંગ તરીકે ગણી શકાય. અક્ષરોની શ્રેણીને બેવડા અવતરણચહ્ન(Double quotes – “ ”)માં લખવામાં આવે છે.
- સ્ટ્રિંગનો સંગ્રહ કરી શકે તેવા ચલ વાપરવા માટે જાવામાં બે પ્રકારની સ્પ્રિંગ આપેલી છે :
- String અને
- String Buffer.
- અહીં આપણે ‘String’ પ્રકારની સ્ટ્રિંગનો અભ્યાસ કરીશું. સ્ટ્રિંગ બનાવવા માટે વપરાતાં કેટલાક કન્સ્ટ્રક્ટર અને તેમનું કાર્ય કોષ્ટક 1માં દર્શાવેલ છે :
કોષ્ટક 1 : સ્ટ્રિંગ બનાવવા માટે વપરાતા કન્સ્ટ્રક્ટર
| કન્સ્ટ્રક્ટર | કાર્ય |
| 1. String( ) | 1. તે એક પણ અક્ષર વગરનો સ્વિંગ ઑબ્જેક્ટ બનાવે છે. |
| 2. String (char ary[ ]) | 2. ary ચલનો પ્રારંભિક કિંમત તરીકે ઉપયોગ કરીને સ્ટ્રિંગ ઑબ્જેક્ટ બનાવે છે. |
| 3. String (char ary[ ], int start, int len) | 3. આપેલા પ્રથમ ચલ aryના start સ્થાનથી len જેટલા ઘટકોનો સ્વિંગ ઑબ્જેક્ટ બનાવે છે. |
| 4. String (String strObj) | 4. ચલ તરીકે આપેલા ઑબ્જેક્ટ જેવો જ સ્વિંગ ઑબ્જેક્ટ બનાવે છે. |
| 5. String (string literal) | 5. ચલ તરીકે આપેલા string literalને નિર્દેશ કરતો સ્ટિંગ ઑબ્જેક્ટ બનાવે છે. |
- આકૃતિ માં વિવિધ પ્રકારના String ક્લાસના કન્સ્ટ્રક્ટરનો ઉપયોગ દર્શાવેલ છે.
- જાવામાં અક્ષરનો સંગ્રહ કરવા માટે અક્ષરદીઠ બે બાઇટ વપરાય છે.
નોંધ : મેમરીમાં જગ્યા બચાવવા માટે જો ASCII અક્ષરો હોય, તો char પ્રકારના ડેટા ઍરે વાપરવાને બદલે bytes પ્રકારના ડેટા ઍરેનો ઉપયોગ કરવો જોઈએ.
- જ્યારે સ્વિંગ ઑબ્જેક્ટ new પ્રક્રિયક વાપરીને બનાવવામાં આવે છે, ત્યારે બંને સ્પ્રિંગ એકસમાન હોય, તોપણ મેમરીમાં અલગ જગ્યા ફાળવવામાં આવે છે.
- આકૃતિ માં આપેલ કોડ લિસ્ટિંગમાં “str1 == str2” એ str1 અને str2 એમ બે રેફરન્સ ચલમાં સંગ્રહ કરેલી વિગતોની તુલના કરે છે.
- અહીં, બંને ચલ str1 અને str2 new પ્રક્રિયક વિના અને એકસરખા સ્ટ્રિંગ લિટરલ વાપરીને બનાવ્યા છે. આથી તેઓ ઇન્સ્ટન્સનો નિર્દેશ કરે છે અને આકૃતિ માં દર્શાવ્યા મુજબ તેમના માટે અલગ મેમરીની ફાળવણી કરવામાં આવી નથી.
- આ જ પ્રોગ્રામમાં str3 અને str4 new પ્રક્રિયકનો ઉપયોગ કરીને બનાવ્યા છે. આથી બંને અલગ મેમરીસ્થાનનો સંદર્ભ ધરાવે છે અને તેમના માટે અલગ મેમરીની ફાળવણી કરવામાં આવી છે. (જુઓ આકૃતિ.)
