જાવા શબ્દમાળા  



જાવા શબ્દમાળા

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

વિષયસુચીકોષ્ટક

જાવામાં સ્ટ્રિંગ બનાવવી  

અમે 2 વિવિધ પદ્ધતિઓનો ઉપયોગ કરીને શબ્દમાળા બનાવી શકીએ છીએ.

  • શબ્દમાળા શબ્દમાળા વાપરી રહ્યા છીએ
  • નવા કીવર્ડનો ઉપયોગ કરી રહ્યા છીએ

શબ્દમાળા શબ્દમાળાની મદદથી શબ્દમાળા બનાવો

આ બનાવવાની સૌથી સીધી રીત છે શબ્દમાળા જાવામાં. આપણે વેલ્યુને ડબલ-અવતરણમાં જોડીને શબ્દમાળા બનાવી શકીએ છીએ. અહીં શબ્દમાળા "વેરીએબલ" વેરીએબલ "જાવા લેંગ્વેજ" નામના શબ્દમાળાને ધરાવે છે

String value = "Java language";

જ્યારે આપણે શબ્દમાળાને શાબ્દિક બનાવીએ છીએ, જો શબ્દમાળા અસ્તિત્વમાં હોય તો JVM પ્રથમ "શબ્દમાળાના સતત પૂલ" માં તપાસ કરે છે. જો તે અસ્તિત્વમાં નથી, તો જેવીએમ નવી સ્ટ્રિંગ ઇન્સ્ટન્સ બનાવે છે, નહીં તો ફક્ત પૂલ કરેલા દાખલાનો સંદર્ભ પાછો આવશે. ઉદાહરણ તરીકે, નીચેના કિસ્સામાં, બંને શબ્દમાળા પદાર્થો સમાન મૂલ્ય ધરાવે છે. તેથી ફક્ત 1 objectબ્જેક્ટ બનાવવામાં આવી છે (એટલે ​​કે એસ 1) અને એસ 2 માં એસ 1 નો સંદર્ભ હશે. આનો અર્થ એ છે કે આપણે સમાન મૂલ્ય સાથે કેટલા સ્ટ્રિંગ વેરિયેબલ્સ બનાવીએ છીએ તે ધ્યાનમાં લીધા વિના, ફક્ત 1 દાખલા શબ્દમાળા સ્થિર પૂલમાં બનાવવામાં આવશે.

“શબ્દમાળા સતત પૂલ” શબ્દમાળા holdબ્જેક્ટ્સને પકડવાની વિશેષ મેમરી સિવાય કંઈ નથી.

String s1 = "Java language"; 
String s2 = "Java language";

જાવામાં શબ્દમાળા

નવા કીવર્ડનો ઉપયોગ કરીને શબ્દમાળા બનાવવી

જ્યારે આપણે એક જ શબ્દમાળા મૂલ્ય ધરાવતાં 2 જુદા જુદા haveબ્જેક્ટ્સ રાખવા માગીએ છીએ, તો પછી આપણે આ મદદથી શબ્દમાળા બનાવીએ છીએ નવા નીચે વર્ણવ્યા મુજબ કીવર્ડ આ કિસ્સામાં, જેવીએમ apગલાની મેમરીમાં 2 જુદા જુદા શબ્દમાળા પદાર્થો બનાવે છે

String s1 = new String("Java");
String s2 = new String("Java");

જાવામાં શબ્દમાળા  

જાવા શબ્દમાળા  

જાવા.અંગ.સ્ટ્રિંગ વર્ગ વિવિધ પદ્ધતિઓનું સમર્થન કરે છે જેનો ઉપયોગ નીચે મુજબ વર્ણવેલ વિવિધ શબ્દમાળા મેનિપ્યુલેશન્સ માટે થાય છે:

આ પણ જુઓ
જાવામાં થ્રેડ
પદ્ધતિવર્ણનમાપદંડ
ચાર ચાર્ટ (પૂર્ણાંક અનુક્રમણિકા)ઇનપુટ શબ્દમાળાના ઉલ્લેખિત અનુક્રમણિકા પર પાત્ર આપે છેઅનુક્રમણિકા - શબ્દમાળાની અનુક્રમણિકા મૂલ્ય
પૂર્ણાંક કોડપોઇન્ટ (પૂર્ણાંક અનુક્રમણિકા)ઉલ્લેખિત અનુક્રમણિકા પર પાત્રનું યુનિકોડ મૂલ્ય પરત કરે છેઅનુક્રમણિકા - શબ્દમાળાની અનુક્રમણિકા મૂલ્ય
પૂર્ણાંક કોડપોઇન્ટ પહેલાં (પૂર્ણાંક અનુક્રમણિકા)ઉલ્લેખિત અનુક્રમણિકા પહેલાં પાત્રનું યુનિકોડ મૂલ્ય આપે છેઅનુક્રમણિકા - શબ્દમાળાની અનુક્રમણિકા મૂલ્ય
પૂર્ણાંક સરખામણી કરો (શબ્દમાળા anotherstring)અક્ષરોના યુનિકોડ મૂલ્યના આધારે 2 તારની તુલના કરે છે અને જો તે દલીલ શબ્દમાળાની આગળ હોય તો નકારાત્મક મૂલ્ય આપે છે, નહીં તો સકારાત્મક વળતર આપે છે. જો બંને શબ્દમાળાઓ સમાન હોય તો વળતર મૂલ્ય 0 છેanotherstring - શબ્દમાળા objectબ્જેક્ટ સાથે તુલના કરવા
પૂર્ણાંક તુલના કરોઆઉનોગોરકેસ (શબ્દમાળા એનોથેરસ્ટ્રિંગ)સરખામણી કરવાની પદ્ધતિ જેવું જ છે સિવાય કે તે કેસને અવગણે છે.anotherstring - શબ્દમાળા objectબ્જેક્ટ સાથે તુલના કરવા
શબ્દમાળા સમ્રાટ (શબ્દમાળા સ્ટ્રિટ)બે શબ્દમાળા મૂલ્યો જોડે છેstr - શબ્દમાળા objectબ્જેક્ટ મૂલ્ય સાથે જોડવું તે શબ્દમાળા
બુલિયન સમાવે છે (CharSequence c)સ્ટ્રિંગમાં ઉલ્લેખિત અક્ષર ક્રમ છે કે કેમ તે તપાસો અને જો હાજર હોય તો સાચું વળતર આપે છેસી - શબ્દમાળા શોધવા માટે અક્ષર ક્રમ
બુલિયન કન્ટેન્ટ એક્વલ્સ (ચાર્ક સીક્વન્સ સી)જો શબ્દમાળામાં ચોક્કસ પાત્રતા શામેલ છે અને જો હાજર હોય તો તે સાચું આપે છેસી - શબ્દમાળા શોધવા માટે અક્ષર ક્રમ
બુલિયન કન્ટેન્ટ ઇક્વલ્સ (શબ્દમાળા બફર એસબી)જો સ્ટ્રિંગમાં ઉલ્લેખિત સ્ટ્રિંગ બફર છે કે કેમ તે તપાસો અને જો હાજર હોય તો સાચું વળતર આપે છેએસબી - શબ્દમાળા બફર સામગ્રી
બુલિયન એન્ડ્સ (શબ્દમાળા પ્રત્યય)જો શબ્દમાળા ઉલ્લેખિત પ્રત્યય સાથે સમાપ્ત થાય છે અને જો હાજર હોય તો સાચું પાછું આવે છે તે તપાસે છેપ્રત્યય - શબ્દમાળા તપાસવા માટે પ્રત્યય
બુલિયન બરાબર (objબ્જેક્ટ )બ્જેક્ટ)પાસ થયેલ passedબ્જેક્ટ સાથે શબ્દમાળા objectબ્જેક્ટની સમાનતા તપાસે છે અને બરાબર હોય તો સાચી આપે છે--બ્જેક્ટ - તુલના કરવાનો .બ્જેક્ટ
બુલિયન બરાબર ઇગ્નોરકેસ (શબ્દમાળા str)કેસને અવગણીને બે શબ્દમાળાઓની તુલના કરો અને જો બંને શબ્દમાળાઓ સમાન હોય તો સાચું વળતર આપે છેstr - તુલના કરવા માટે શબ્દમાળા
પૂર્ણાંક અનુક્રમણિકા (પૂર્ણાંક સીએચ)શબ્દમાળામાં ઉલ્લેખિત યુનિકોડ પાત્રની પ્રથમ ઘટનાની અનુક્રમણિકા આપે છેસીએચ - અક્ષરનું યુનિકોડ મૂલ્ય
પૂર્ણાંક અનુક્રમણિકા (શબ્દમાળા str)શબ્દમાળામાં ઉલ્લેખિત સબસ્ટ્રિંગની પ્રથમ ઘટનાની અનુક્રમણિકા પરત કરે છેસ્ટ્રિંગ - શબ્દમાળામાં સબસ્ટ્રિંગ વેલ્યુ હાજર છે
બુલિયન ઇઝ બ્લેક ()સાચું વળતર એ શબ્દમાળા ખાલી છે અથવા ફક્ત ખાલી જગ્યાઓ શામેલ છે
બુલિયન ઇફેટી ()જો શબ્દમાળા ખાલી હોય તો સાચું પરત કરે છે (એટલે ​​કે લંબાઈ 0 છે)
પૂર્ણાંક છેલ્લાશબ્દમાળામાં ઉલ્લેખિત યુનિકોડ પાત્રની છેલ્લી ઘટનાની અનુક્રમણિકા આપે છેસીએચ - અક્ષરનું યુનિકોડ મૂલ્ય
પૂર્ણાંક lastindexOf (શબ્દમાળા str)શબ્દમાળામાં ઉલ્લેખિત સબસ્ટ્રિંગની છેલ્લી ઘટનાની અનુક્રમણિકા પરત કરે છેસ્ટ્રિંગ - શબ્દમાળામાં સબસ્ટ્રિંગ વેલ્યુ હાજર છે
પૂર્ણાંક લંબાઈ ()શબ્દમાળાની લંબાઈ પરત કરે છે
બુલિયન મેચ (શબ્દમાળા રેજેક્સ)જો શબ્દમાળા ઉલ્લેખિત નિયમિત અભિવ્યક્તિ સાથે મેળ ખાતી હોય તો સાચું પરત આપે છેરેજેક્સ - નિયમિત અભિવ્યક્તિ તપાસવી
શબ્દમાળા પુનરાવર્તન (પૂર્ણાંક ગણતરી)ગણતરીના આધારે શબ્દમાળાને જોડે છેગણતરી - ઇનપુટ શબ્દમાળા જોડવા માટે સંખ્યા
શબ્દમાળા બદલો (ચાર ઓલ્ડચર, ચાર ન્યુચર)પાત્રની બધી ઘટનાઓને નવા પાત્રથી બદલીને નવી શબ્દમાળા પરત કરે છેOldchar - બદલવા માટે પાત્ર
newchar - અક્ષર બદલવા માટે
શબ્દમાળા [] સ્પ્લિટ (શબ્દમાળા regexp)નિયમિત અભિવ્યક્તિના આધારે શબ્દમાળા વિભાજિત થાય છે. તે એરે પરત આપે છેregexp - શબ્દમાળાને વિભાજીત કરવા માટે સીમાંકક
શબ્દમાળા [] સ્પ્લિટ (શબ્દમાળા regexp, પૂર્ણાંક મર્યાદા)નિયમિત અભિવ્યક્તિ અને તેને લાગુ કરવાની જરૂર છે તે સંખ્યાના આધારે શબ્દમાળા વિભાજિત કરે છેregexp - શબ્દમાળાને વિભાજીત કરવા માટે સીમાંકક
મર્યાદા - પેટર્ન લાગુ કરવાની સંખ્યાની સંખ્યા
બુલિયન પ્રારંભ સાથે (શબ્દમાળાના ઉપસર્ગ)આપેલ શબ્દમાળા ઉલ્લેખિત ઉપસર્ગથી શરૂ થાય છે કે કેમ તે તપાસે છે. જો હાજર હોય તો સાચું પરત આપે છેઉપસર્ગ - શબ્દમાળા તપાસવા માટેનો ઉપસર્ગ
બુલિયન પ્રારંભ થાય છે સાથે (શબ્દમાળાના ઉપસર્ગ, પૂર્ણાંક ટૂફસેટ)આપેલ શબ્દમાળા ટૂફસેટ પરિમાણના આધારે નિર્ધારિત ઉપસર્ગથી શરૂ થાય છે કે કેમ તે તપાસે છે.ઉપસર્ગ - શબ્દમાળા તપાસવા માટેનો ઉપસર્ગ
ટoffફસેટ - અનુક્રમણિકા જ્યાંથી શોધ શરૂ કરવાની જરૂર છે
શબ્દમાળા પટ્ટી ()અગ્રણી અને પાછળની બંને બાજુથી દૂર કરેલા તમામ ગોરા સ્થાનો સાથે સ્ટ્રિંગ આપે છે
શબ્દમાળા સ્ટ્રીપલિડિંગ ()બધી અગ્રણી જગ્યાઓ કા removedીને સ્ટ્રિંગનો સબસ્ટ્રિંગ આપે છે
શબ્દમાળા સ્ટ્રીપટ્રેઇલિંગ ()બધી ટ્રેલિંગ જગ્યાઓ કા removedીને સ્ટ્રિંગનો સબસ્ટ્રિંગ પરત કરે છે
ચારસેક્વેન્સ સબસિક્વન્સ (પૂર્ણાંક પ્રારંભિક સૂચિ, પૂર્ણાંક અંતિમ ઇન્ડેક્સ)પ્રારંભ અને અંત અનુક્રમણિકાના આધારે શબ્દમાળાના પાત્ર ક્રમ પરત કરે છેસ્ટાર્ટઇંડેક્સ - અનુક્રમણિકા જ્યાંથી સબસ્ટ્રિંગને ફરીથી પ્રાપ્ત કરવી પડશે
એન્ડિડેક્સ - અનુક્રમણિકા જ્યાં સુધી સબસ્ટ્રિંગ પુન .પ્રાપ્ત કરવી પડશે
શબ્દમાળા સબસ્ટ્રિંગ (પૂર્ણાંક પ્રારંભ)પ્રારંભ અનુક્રમણિકાના આધારે સ્ટ્રિંગનો સબસ્ટ્રિંગ આપે છેસ્ટાર્ટઇંડેક્સ - અનુક્રમણિકા જ્યાંથી સબસ્ટ્રિંગને ફરીથી પ્રાપ્ત કરવી પડશે
શબ્દમાળા સબસ્ટ્રિંગ (પૂર્ણાંક સ્ટાર્ટઇન્ડેક્સ, પૂર્ણાંક અંતિમ સૂચિ)પ્રારંભ અને અંત અનુક્રમણિકાના આધારે સ્ટ્રિંગનો સબસ્ટ્રિંગ આપે છેસ્ટાર્ટઇંડેક્સ - અનુક્રમણિકા જ્યાંથી સબસ્ટ્રિંગને ફરીથી પ્રાપ્ત કરવી પડશે
એન્ડિડેક્સ - અનુક્રમણિકા જ્યાં સુધી સબસ્ટ્રિંગ પુન .પ્રાપ્ત કરવી પડશે
ચાર [] થી ચાર્અરે ()શબ્દમાળાને પાત્ર એરેમાં ફેરવે છે
શબ્દમાળાથી લowerવરકેસ ()શબ્દમાળાના બધા પાત્રોને લોઅરકેસમાં ફેરવે છે
સ્ટ્રિંગ ટૂ લાવરકેસ (લોકેલ લોકેલ)શબ્દનાં બધાં પાત્રોને લોકેલનાં નિયમોનાં આધારે લોઅરકેસમાં ફેરવે છેલોકેલ - લાગુ કરવાના લોકેલ નિયમો
સ્ટ્રિંગ ટૂ સ્ટ્રિંગ ()શબ્દમાળા પોતે જ આપે છે
અપરકેસ શબ્દમાળા ()શબ્દમાળાના બધા અક્ષરોને અપર કેસમાં રૂપાંતરિત કરે છે
અપરકેસ શબ્દમાળા (લોકેલ લોકેલ)શબ્દનાં તમામ પાત્રોને લોકેલનાં નિયમોના આધારે અપર કેસમાં ફેરવે છેલોકેલ - લાગુ કરવાના લોકેલ નિયમો
શબ્દમાળા ટ્રીમ ()બધી અગ્રણી અને પાછળની જગ્યાઓ કા aીને સ્ટ્રિંગ આપે છે
શબ્દમાળા બંધારણ સ્ટ્રિંગ (શબ્દમાળા બંધારણ, jectબ્જેક્ટ ... આર્ગ્સ)ફોર્મેટ અને દલીલોના આધારે ફોર્મેટ કરેલ શબ્દમાળા પરત કરે છેફોર્મેટ - ફોર્મેટ નિર્દિષ્ટ
આર્ગ્સ - ફોર્મેટ સ્પષ્ટીકરણ દ્વારા સંદર્ભિત દલીલો
શબ્દમાળા જોડાઓ (CharSequence સીમાંકન, CharSequence ... તત્વો)સીમાંકકનો ઉપયોગ કરીને પાત્ર ક્રમ તત્વોમાં જોડાય છેસીમાંકક - જોડાવા માટેનો સીમાંકક
તત્વો - જોડાવા માટે શબ્દમાળા તત્વો
શબ્દમાળા મૂલ્ય (બુલિયન બી)બુલિયન દલીલની શબ્દમાળા રજૂઆત પરત કરે છે. જો સાચું પસાર થાય છે, તો સાચું વળતર આપે છેb - બુલિયન વેલ્યુ સાચા કે ખોટા
શબ્દમાળા મૂલ્યથી (ચાર સી)પાત્ર દલીલની શબ્દમાળા રજૂઆત પરત કરે છેસી - પાત્ર
શબ્દમાળા મૂલ્યથી (ચાર્ [] ડેટા)પાત્ર એરે દલીલની શબ્દમાળા રજૂઆત આપે છેડેટા - અક્ષર એરે
શબ્દમાળા મૂલ્ય (ડબલ ડી)ડબલ દલીલની શબ્દમાળા રજૂઆત આપે છેડી - ડબલ મૂલ્ય
શબ્દમાળા મૂલ્ય (ફ્લોટ એફ)ફ્લોટ દલીલની શબ્દમાળા રજૂઆત આપે છેએફ - ફ્લોટ મૂલ્ય
શબ્દમાળા મૂલ્ય (પૂર્ણાંક)પૂર્ણાંક દલીલની શબ્દમાળા રજૂઆત આપે છેi - પૂર્ણાંક મૂલ્ય
શબ્દમાળા મૂલ્યઆઇઓફ (લાંબી એલ)લાંબી દલીલની શબ્દમાળા રજૂઆત આપે છેl - લાંબી કિંમત
શબ્દમાળા મૂલ્ય (ઓબ્જેક્ટ )બ્જેક્ટ)Argumentબ્જેક્ટ દલીલની શબ્દમાળા રજૂઆત પરત કરે છેવાંધો - પદાર્થ
શબ્દમાળા મૂલ્યથી (ચાર્ [] ડેટા, પૂર્ણાંક offફસેટ, પૂર્ણાંક ગણતરી)Setફસેટ અને ગણતરીના આધારે વિશિષ્ટ સબ્રિંગ અક્ષર એરે દલીલની સ્ટ્રિંગ રજૂઆત પરત આપે છેડેટા - અક્ષર એરે
setફસેટ - પ્રારંભ અનુક્રમણિકા
ગણતરી - સબસ્ટ્રિંગની લંબાઈ
આ પણ જુઓ
જાવા માં કlaલેબલ અને ફ્યુચર ઇન્ટરફેસ

ઉદાહરણ: એરે અક્ષરોમાંથી શબ્દમાળા બનાવવા માટે જાવા પ્રોગ્રામ  

નીચેના ઉદાહરણમાં, આપણે એકને કન્વર્ટ કરીએ છીએ એરે નવા કીવર્ડનો ઉપયોગ કરીને જાવાનાં શબ્દમાળા અક્ષરો.

public class StringDemo1 {

  public static void main(String[] args) {
    char[] c = {'j','a','v','a'};
    String s = new String(c);
    System.out.println(s);
    
  }

}
Output:
java

ઉદાહરણ: લંબાઈ (), ચારઅટ () અને ઇન્ડેક્સઓફ () પદ્ધતિઓનો ઉપયોગ કરવો  

નીચેનું ઉદાહરણ તમને બતાવે છે કે કેવી રીતે કોઈ વિશેષ અનુક્રમણિકા પર કોઈ પાત્ર પાછું મેળવવા, શબ્દમાળાની લંબાઈ મેળવવા અને વિશિષ્ટ પાત્રની અનુક્રમણિકા પ્રાપ્ત કરવી.

public class StringDemo2 {

  public static void main(String[] args) {
    String s1 = new String("Java tutorial");
    System.out.println("The character at index 6 is : " + s1.charAt(6));
    System.out.println("The length of the input string is : " + s1.length());
    System.out.println("The index of letter 'v' is : " + s1.indexOf('v'));
  }

}
Output:
The character at index 6 is : u
The length of the input string is : 13
The index of letter 'v' is : 2

ઉદાહરણ: કમ્પેકટટ compare (), કન્ટેન્ટ ઇક્વેલ્સ () અને () સમાવે છે  

આ ઉદાહરણ જાવામાં 2 તારની તુલના બતાવે છે

  1. સરખામણી કરો () અહીં સકારાત્મક પૂર્ણાંકો આપે છે કારણ કે ઇનપુટ શબ્દમાળા દલીલ શબ્દમાળાને સફળ કરે છે.
  2. સરખામણી કરો. ઇગ્નોરકેસ () 0 આપે છે કારણ કે બંને શબ્દમાળા કેસની અનુલક્ષીને સમાન છે.
  3. સમાવે છે () સાચું વળતર આપે છે કારણ કે ઇનપુટ શબ્દમાળામાં દલીલ શબ્દમાળા હોય છે
  4. કન્ટેન્ટ ઇક્વેલ્સ () ખોટા વળતર આપે છે કારણ કે ઇનપુટ શબ્દમાળામાં ચોક્કસ દલીલ શબ્દમાળા નથી.
public class StringDemo2 {

  public static void main(String[] args) {
    String s1 = new String("Java tutorial");
    System.out.println("Comparison of input string with argument is : " + s1.compareTo("C++"));
    System.out.println("Comparison of input string with argument ignoring case is : " + s1.compareToIgnoreCase("JAVA TUTORIAL"));
    System.out.println("Output of contains method: " + s1.contains("tutorial"));
    System.out.println("Output of contentEquals method: " + s1.contentEquals("Java"));
    }
}
Output:
Comparison of input string with argument is : 7
Comparison of input string with argument ignoring case is : 0
Output of contains method: true
Output of contentEquals method: false

ઉદાહરણ: બરાબર ઉપયોગ કરીને ()  

1 લી આઉટપુટ ખોટું છે કારણ કે સામગ્રી સમાન હોવા છતાં કેસ મેળ ખાતો નથી. સામગ્રી અને કેસની મેળ ખાતી હોવાથી 2 જી આઉટપુટ સાચું છે.

આ પણ જુઓ
ઝિગઝેગ કન્વર્ઝન

3 જી આઉટપુટ ખોટું છે કારણ કે બંને સામગ્રી અલગ છે.

public class StringDemo3 {

  public static void main(String[] args) {
    String s1 = "java tutorial";
    String s2 = "Java Tutorial";
    String s3 = "java tutorial";
    String s4 = "Tutorial cup";
    System.out.println(s1.equals(s2));
    System.out.println(s1.equals(s3));
    System.out.println(s1.equals(s4));
  }

}
Output:
false
true
false

ઉદાહરણ: સ્ટ્રિંગ્સનું કન્ટેન્ટેશન  

આપણે કોંકટ () ની મદદથી જાવા માં 2 તાર જોડી શકીએ છીએ. જાવા ની પદ્ધતિ શબ્દમાળા વર્ગ. “+” નો ઉપયોગ 2 અથવા વધુ શબ્દમાળાઓ જોડવા માટે પણ થાય છે જે સામાન્ય રીતે પ્રિંટ સ્ટેટમેન્ટમાં વપરાય છે. 2 શબ્દમાળાઓ જોડતા, શબ્દમાળાઓ વચ્ચે જગ્યા શામેલ નથી. નીચેના ઉદાહરણમાં, શબ્દમાળા એસ 3 માં એસ 1 અને એસ 2 નું એકંદરેલું મૂલ્ય છે જે પ્રિંટ સ્ટેટમેન્ટમાં નવી સ્ટ્રિંગ સાથે વપરાય છે.

આપણે જાવા (join) (મેથડ) મેથડની મદદથી 2 શબ્દમાળાઓ પણ જોડી શકીએ છીએ. આ સ્પષ્ટ કરેલ સીમાંકક સાથે દલીલમાં પસાર કરેલા શબ્દોમાં જોડાશે.

public class StringConcat {

  public static void main(String[] args) {
    String s1 = "Hello,";
    String s2 = "how are you";
    String s3 = s1.concat(s2);
    System.out.println(s3 + " today");
    System.out.println(s1.join(",", "welcome","to","tutorialcup"));
  }

}
Output:
Hello,how are you today
welcome,to,tutorialcup

ઉદાહરણ: જાવા પ્રોગ્રામ, અપર કેસ અને લોઅર કેસ વચ્ચે સ્ટ્રિંગ કન્વર્ટ કરવા માટે  

public class StringCase {

  public static void main(String[] args) {
    String s1 = "Welcome to tutorialcup";
    System.out.println("Convert to lower case: " + s1.toLowerCase());
    System.out.println("Convert to upper case: " + s1.toUpperCase());

  }

}
Output:
Convert to lower case: welcome to tutorialcup
Convert to upper case: WELCOME TO TUTORIALCUP

ઉદાહરણ: જાવામાં સબસ્ટ્રિંગનો ઉપયોગ કરવો  

આપણે જાવા માં શબ્દમાળા નો ભાગ વાપરી શકીએ છીએ સબસ્ટ્રિંગ પદ્ધતિ. અનુક્રમણિકા મૂલ્ય 0 થી શરૂ થાય છે.

public class StringDemo3 {

  public static void main(String[] args) {
    String s1 = "java tutorial";
    System.out.println(s1.substring(3));
    System.out.println(s1.substring(1, 10));
  }

}
Output:
a tutorial
ava tutor

ઉદાહરણ: વિભાજન અને બદલો નો ઉપયોગ  

જાવામાં સ્ટ્રિંગની બીજી સૌથી વધુ ઉપયોગમાં લેવાતી પદ્ધતિ સ્પ્લિટ છે. આ ઉદાહરણમાં, આપણે પહેલા સીમાચિહ્ન "" નો ઉપયોગ કરીને ઇનપુટ શબ્દમાળાને વિભાજીત કરીએ છીએ. તેથી આ દરેક શબ્દને અલગથી છાપે છે. આગળ, આપણે સીમાંકકના આધારે વિભાજીત કરીએ છીએ પરંતુ મર્યાદા 2 તરીકે નિર્દિષ્ટ કરીએ છીએ જેનો અર્થ તે માત્ર બે શબ્દમાળા એરે મૂલ્યોમાં વિભાજિત થાય છે.

આ પણ જુઓ
જાવામાં સબસ્ટ્રિંગ શું છે

બદલવાના 1 લી ઉદાહરણમાં, અમે વ્યક્તિગત પાત્રને બદલીએ છીએ. આગળ, આપણે પાત્ર ક્રમ બદલીએ છીએ.

public class StringDemo4 {

  public static void main(String[] args) {
    String str1 = "Welcome to java programming";
    System.out.println("Split output using delimiter:");
    //Split using only delimiter
    String[] arrval = str1.split(" ");
    for(int i=0;i<arrval.length;i++) {
      System.out.println(arrval[i]);
    }
    System.out.println("\nSplit output using delimiter and limit:");
    //Split using delimiter and limit
    String[] arrval2 = str1.split(" ", 2);
    for(int i=0;i<arrval2.length;i++) {
      System.out.println(arrval2[i]);
    }
    
    System.out.println("\nReplace output with character:");
    //Replace character
    String str2 = str1.replace('j', 'J');
    System.out.println(str2);
    System.out.println("\nReplace output with character sequence:");
    String str3 = str1.replace("java", "javascript");
    System.out.println(str3);
  }

}


Output:
Split output using delimiter:
Welcome
to
java
programming

Split output using delimiter and limit:
Welcome
to java programming

Replace output with character:
Welcome to Java programming

Replace output with character sequence:
Welcome to javascript programming

ઉદાહરણ: જાવા ફોર્મેટ શબ્દમાળા  

આપણે કોઈપણ ફોર્મેટ કરી શકીએ છીએ ડેટા પ્રકાર ફોર્મેટ મેથડનો ઉપયોગ કરીને સ્ટ્રિંગમાં. અહીં, આપણે ઉદાહરણો તરીકે શબ્દમાળા ("% s"), ફ્લોટ (% f ") અને બુલિયન ("% b ") વાપરી રહ્યા છીએ.

public class StringFormat {

  public static void main(String[] args) {
    String str = "Java";
    String formatstring1 = String.format("Programming language is %s",str);
    String formatstring2 = String.format("Float value is %f", 55.6789);
    String formatstring3 = String.format("Boolean value is %b", true);
    System.out.println(formatstring1);
    System.out.println(formatstring2);
    System.out.println(formatstring3);
  }

}
Output:
Programming language is Java
Float value is 55.678900
Boolean value is true

ઉપસંહાર  

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

સંદર્ભ