സ്ട്രിംഗ് രീതികൾ ജാവ



ജാവ സ്ട്രിംഗ്

ജാവ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ, ഒരു സ്ട്രിംഗ് എന്നത് പ്രതീകങ്ങളുടെ ഒരു ശ്രേണി മാത്രമാണ്. ഇത് ഏറ്റവും വ്യാപകമായി ഉപയോഗിക്കുന്ന വസ്തുവാണ്. ജാവ സ്ട്രിംഗ് ക്ലാസിന് വിവിധ കൃത്രിമത്വങ്ങൾക്കായി ഉപയോഗിക്കുന്ന നിരവധി രീതികളുണ്ട്. ഇത് മാറ്റമില്ലാത്തതാണ്, അർത്ഥം, അതിന്റെ മൂല്യം മാറ്റാൻ കഴിയില്ല. ഒരു സ്ട്രിംഗ് പ്രതീകങ്ങളുടെ ഒരു നിരയ്ക്ക് തുല്യമാണ്.

ഉള്ളടക്ക പട്ടിക

ജാവയിൽ ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കുന്നു

2 വ്യത്യസ്ത രീതികൾ ഉപയോഗിച്ച് നമുക്ക് ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കാൻ കഴിയും:

  • സ്ട്രിംഗ് അക്ഷരാർത്ഥത്തിൽ ഉപയോഗിക്കുന്നു
  • പുതിയ കീവേഡ് ഉപയോഗിക്കുന്നു

അക്ഷരാർത്ഥത്തിൽ ഒരു സ്ട്രിംഗ് ഉപയോഗിച്ച് ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കുക

ഇത് സൃഷ്ടിക്കുന്നതിനുള്ള ഏറ്റവും നേരിട്ടുള്ള മാർഗമാണിത് സ്ട്രിംഗ് ജാവയിൽ. ഇരട്ട ഉദ്ധരണികളിൽ മൂല്യം ഉൾപ്പെടുത്തിക്കൊണ്ട് നമുക്ക് ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കാൻ കഴിയും. സ്ട്രിംഗ് തരത്തിന്റെ വേരിയബിൾ “മൂല്യം” “ജാവ ഭാഷ” എന്ന് പേരിട്ടിരിക്കുന്ന സ്ട്രിംഗ് പിടിക്കുന്നു

String value = "Java language";

ഞങ്ങൾ അക്ഷരാർത്ഥത്തിൽ ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കുമ്പോൾ, സ്ട്രിംഗ് നിലവിലുണ്ടെങ്കിൽ ജെവിഎം ആദ്യം “സ്ട്രിംഗ് കോൺസ്റ്റന്റ് പൂളിൽ” പരിശോധിക്കുന്നു. അത് നിലവിലില്ലെങ്കിൽ, ജെ‌വി‌എം ഒരു പുതിയ സ്‌ട്രിംഗ് ഉദാഹരണം സൃഷ്‌ടിക്കുന്നു, അല്ലാത്തപക്ഷം പൂൾ ചെയ്‌ത ഉദാഹരണത്തെക്കുറിച്ചുള്ള ഒരു റഫറൻസ് മാത്രമേ തിരികെ നൽകൂ. ഉദാഹരണത്തിന്, ചുവടെയുള്ള കേസിൽ, രണ്ട് സ്ട്രിംഗ് ഒബ്ജക്റ്റുകളും ഒരേ മൂല്യമാണ്. അതിനാൽ 1 ഒബ്ജക്റ്റ് മാത്രമേ സൃഷ്ടിക്കൂ (അതായത് എസ് 1), എസ് 2 ന് എസ് 1 റഫറൻസ് ഉണ്ടാകും. ഇതിനർത്ഥം, ഒരേ മൂല്യത്തിൽ ഞങ്ങൾ എത്ര സ്ട്രിംഗ് വേരിയബിളുകൾ സൃഷ്ടിച്ചാലും, സ്ട്രിംഗ് നിരന്തരമായ പൂളിൽ 1 ഉദാഹരണം മാത്രമേ സൃഷ്ടിക്കൂ.

“സ്‌ട്രിംഗ് കോൺസ്റ്റന്റ് പൂൾ” എന്നത് സ്‌ട്രിംഗ് ഒബ്‌ജക്റ്റുകൾ പിടിക്കാനുള്ള പ്രത്യേക മെമ്മറിയല്ലാതെ മറ്റൊന്നുമല്ല.

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

ജാവയിലെ സ്ട്രിംഗ്

പുതിയ കീവേഡ് ഉപയോഗിച്ച് ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കുന്നു

ഒരേ സ്ട്രിംഗ് മൂല്യം കൈവശമുള്ള 2 വ്യത്യസ്ത ഒബ്ജക്റ്റുകൾ ലഭിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ, ഞങ്ങൾ ഉപയോഗിച്ച് ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കുന്നു പുതിയ കീവേഡ് ചുവടെ വിവരിച്ചിരിക്കുന്നത് പോലെ. ഈ സാഹചര്യത്തിൽ, ജെവിഎം ഒരു കൂമ്പാര മെമ്മറിയിൽ 2 വ്യത്യസ്ത സ്ട്രിംഗ് ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുന്നു

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

ജാവയിലെ സ്ട്രിംഗ്

സ്ട്രിംഗ് രീതികൾ ജാവ

താഴെ വിവരിച്ചിരിക്കുന്നതുപോലെ വ്യത്യസ്ത സ്ട്രിംഗ് കൃത്രിമത്വത്തിനായി ഉപയോഗിക്കുന്ന വിവിധ രീതികളെ java.lang.String ക്ലാസ് പിന്തുണയ്ക്കുന്നു:

രീതിവിവരണംപരാമീറ്ററുകൾ
char charAt (int സൂചിക)ഇൻപുട്ട് സ്ട്രിംഗിന്റെ നിർദ്ദിഷ്ട സൂചികയിൽ പ്രതീകം നൽകുന്നുസൂചിക - സ്ട്രിംഗിന്റെ സൂചിക മൂല്യം
int codePointAt (int സൂചിക)നിർദ്ദിഷ്ട സൂചികയിൽ പ്രതീകത്തിന്റെ യൂണിക്കോഡ് മൂല്യം നൽകുന്നുസൂചിക - സ്ട്രിംഗിന്റെ സൂചിക മൂല്യം
int codePointBefore (int സൂചിക)നിർദ്ദിഷ്ട സൂചികയ്‌ക്ക് മുമ്പുള്ള പ്രതീകത്തിന്റെ യൂണിക്കോഡ് മൂല്യം നൽകുന്നുസൂചിക - സ്ട്രിംഗിന്റെ സൂചിക മൂല്യം
int താരതമ്യം ടു (സ്ട്രിംഗ് മറ്റൊരു സ്ട്രിംഗ്)പ്രതീകങ്ങളുടെ യൂണിക്കോഡ് മൂല്യത്തെ അടിസ്ഥാനമാക്കി 2 സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുകയും അത് ആർഗ്യുമെന്റ് സ്ട്രിംഗിനെ മറികടക്കുകയാണെങ്കിൽ നെഗറ്റീവ് മൂല്യം നൽകുകയും ചെയ്യുന്നു, അല്ലെങ്കിൽ പോസിറ്റീവ് നൽകുന്നു. രണ്ട് സ്ട്രിംഗുകളും തുല്യമാണെങ്കിൽ റിട്ടേൺ മൂല്യം 0 ആണ്മറ്റൊരു സ്ട്രിംഗ് - സ്ട്രിംഗ് ഒബ്ജക്റ്റുമായി താരതമ്യപ്പെടുത്താനുള്ള സ്ട്രിംഗ്
int താരതമ്യം ToIgnoreCase (സ്ട്രിംഗ് മറ്റൊരു സ്ട്രിംഗ്)കേസിനെ അവഗണിക്കുന്നു എന്നതൊഴിച്ചാൽ താരതമ്യപ്പെടുത്താൻ രീതിക്ക് സമാനമാണ്.മറ്റൊരു സ്ട്രിംഗ് - സ്ട്രിംഗ് ഒബ്ജക്റ്റുമായി താരതമ്യപ്പെടുത്താനുള്ള സ്ട്രിംഗ്
സ്ട്രിംഗ് കോൺകാറ്റ് (സ്ട്രിംഗ് സ്ട്രിംഗ്)രണ്ട് സ്ട്രിംഗ് മൂല്യങ്ങൾ സംയോജിപ്പിക്കുന്നുstr - സ്ട്രിംഗ് ഒബ്ജക്റ്റ് മൂല്യവുമായി സംയോജിപ്പിക്കുന്നതിനുള്ള സ്ട്രിംഗ്
ബൂലിയൻ അടങ്ങിയിരിക്കുന്നു (CharSequence c)സ്‌ട്രിംഗിൽ നിർദ്ദിഷ്‌ട പ്രതീക ശ്രേണി അടങ്ങിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുകയും നിലവിലുണ്ടെങ്കിൽ അത് ശരിയാക്കുകയും ചെയ്യുന്നുc - സ്‌ട്രിംഗിൽ കണ്ടെത്താനുള്ള പ്രതീക ശ്രേണി
ബൂളിയൻ ഉള്ളടക്ക എക്വലുകൾ (ചാർ‌സെക്വൻസ് സി)സ്‌ട്രിംഗിൽ കൃത്യമായ പ്രതീകഫലമുണ്ടോയെന്ന് പരിശോധിക്കുകയും നിലവിലുണ്ടെങ്കിൽ അത് ശരിയാക്കുകയും ചെയ്യുന്നുc - സ്‌ട്രിംഗിൽ കണ്ടെത്താനുള്ള പ്രതീക ശ്രേണി
ബൂളിയൻ ഉള്ളടക്ക എക്വലുകൾ (സ്ട്രിംഗ്ബഫർ എസ്ബി)സ്‌ട്രിംഗിൽ നിർദ്ദിഷ്‌ട സ്‌ട്രിംഗ് ബഫർ അടങ്ങിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുകയും നിലവിലുണ്ടെങ്കിൽ അത് ശരിയാക്കുകയും ചെയ്യുന്നുsb - സ്ട്രിംഗ് ബഫർ ഉള്ളടക്കം
ബൂളിയൻ അറ്റങ്ങൾ (സ്ട്രിംഗ് സഫിക്‌സ്)നിർദ്ദിഷ്ട സഫിക്‌സിൽ സ്‌ട്രിംഗ് അവസാനിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുകയും നിലവിലുണ്ടെങ്കിൽ അത് ശരിയാകുകയും ചെയ്യുന്നുസഫിക്‌സ് - സ്‌ട്രിംഗിൽ പരിശോധിക്കാനുള്ള പ്രത്യയം
ബൂളിയൻ സമം (ഒബ്ജക്റ്റ് ഒബ്ജക്റ്റ്)കടന്നുപോയ ഒബ്‌ജക്റ്റുമായി സ്‌ട്രിംഗ് ഒബ്‌ജക്റ്റിന്റെ സമാനത പരിശോധിക്കുകയും തുല്യമാണെങ്കിൽ ശരിയാക്കുകയും ചെയ്യുന്നുobj - താരതമ്യം ചെയ്യാനുള്ള ഒബ്ജക്റ്റ്
ബൂളിയൻ സമം ഇഗ്നോർകേസ് (സ്ട്രിംഗ് സ്ട്രിംഗ്)കേസ് അവഗണിച്ചുകൊണ്ട് രണ്ട് സ്ട്രിംഗിനെ താരതമ്യം ചെയ്യുകയും രണ്ട് സ്ട്രിംഗുകളും തുല്യമാണെങ്കിൽ ശരിയാക്കുകയും ചെയ്യുന്നുstr - താരതമ്യം ചെയ്യാനുള്ള സ്ട്രിംഗ്
int indexOf (int ch)സ്‌ട്രിംഗിലെ നിർദ്ദിഷ്ട യൂണിക്കോഡ് പ്രതീകത്തിന്റെ ആദ്യ സംഭവത്തിന്റെ സൂചിക നൽകുന്നുch - പ്രതീകത്തിന്റെ യൂണിക്കോഡ് മൂല്യം
int indexOf (സ്ട്രിംഗ് സ്ട്രിംഗ്)സ്‌ട്രിംഗിലെ നിർദ്ദിഷ്ട സബ്‌സ്ട്രിംഗിന്റെ ആദ്യ സംഭവത്തിന്റെ സൂചിക നൽകുന്നുstr - സ്‌ട്രിംഗിൽ നിലവിലുള്ള സബ്‌സ്ട്രിംഗ് മൂല്യം
ബൂളിയൻ isBlank ()സ്‌ട്രിംഗ് ശൂന്യമാണെന്നോ ശൂന്യമായ ഇടങ്ങൾ മാത്രമാണെന്നോ ശരിയാണ്
ബൂളിയൻ isEmpty ()സ്ട്രിംഗ് ശൂന്യമാണെങ്കിൽ ശരി നൽകുന്നു (അതായത് നീളം 0)
int lastindexOf (int ch)സ്‌ട്രിംഗിലെ നിർദ്ദിഷ്ട യൂണിക്കോഡ് പ്രതീകത്തിന്റെ അവസാന സംഭവത്തിന്റെ സൂചിക നൽകുന്നുch - പ്രതീകത്തിന്റെ യൂണിക്കോഡ് മൂല്യം
int lastindexOf (സ്ട്രിംഗ് സ്ട്രിംഗ്)സ്‌ട്രിംഗിലെ നിർദ്ദിഷ്‌ട സബ്‌സ്ട്രിംഗിന്റെ അവസാന സംഭവത്തിന്റെ സൂചിക നൽകുന്നുstr - സ്‌ട്രിംഗിൽ നിലവിലുള്ള സബ്‌സ്ട്രിംഗ് മൂല്യം
int ദൈർഘ്യം ()സ്‌ട്രിംഗിന്റെ ദൈർഘ്യം നൽകുന്നു
ബൂളിയൻ പൊരുത്തങ്ങൾ (സ്ട്രിംഗ് റിജെക്സ്)നിർദ്ദിഷ്ട പതിവ് എക്‌സ്‌പ്രഷനുമായി സ്‌ട്രിംഗ് പൊരുത്തപ്പെടുന്നുവെങ്കിൽ ശരി നൽകുന്നുregex - പരിശോധിക്കേണ്ട പതിവ് പദപ്രയോഗം
സ്ട്രിംഗ് ആവർത്തനം (int എണ്ണം)എണ്ണത്തെ അടിസ്ഥാനമാക്കി സ്ട്രിംഗ് സംയോജിപ്പിക്കുന്നുഎണ്ണം - ഇൻ‌പുട്ട് സ്‌ട്രിംഗ് സംയോജിപ്പിക്കുന്നതിനുള്ള തവണകളുടെ എണ്ണം
സ്ട്രിംഗ് മാറ്റിസ്ഥാപിക്കൽ (ചാർ ഓൾഡ്‌ചാർ, ചാർ ന്യൂചാർ)പ്രതീകത്തിന്റെ എല്ലാ സംഭവങ്ങളും പുതിയ പ്രതീകം ഉപയോഗിച്ച് മാറ്റി പുതിയ സ്ട്രിംഗ് നൽകുന്നുoldchar - മാറ്റിസ്ഥാപിക്കാനുള്ള പ്രതീകം
newchar - മാറ്റിസ്ഥാപിക്കേണ്ട പ്രതീകം
സ്ട്രിംഗ് [] സ്പ്ലിറ്റ് (സ്ട്രിംഗ് റിജെക്സ്പി)പതിവ് എക്‌സ്‌പ്രഷനെ അടിസ്ഥാനമാക്കി സ്‌ട്രിംഗ് വിഭജിക്കുന്നു. ഇത് ശ്രേണി നൽകുന്നുregexp - സ്ട്രിംഗ് വിഭജിക്കാനുള്ള ഡിലിമിറ്റർ
സ്ട്രിംഗ് [] വിഭജനം (സ്ട്രിംഗ് റിജെക്സ്പി, ഇന്റന്റ് പരിധി)പതിവ് എക്‌സ്‌പ്രഷനെയും അത് പ്രയോഗിക്കേണ്ട തവണകളുടെ എണ്ണത്തെയും അടിസ്ഥാനമാക്കി സ്‌ട്രിംഗ് വിഭജിക്കുന്നുregexp - സ്ട്രിംഗ് വിഭജിക്കാനുള്ള ഡിലിമിറ്റർ
പരിധി - പാറ്റേൺ എത്ര തവണ പ്രയോഗിക്കണം
ബൂളിയൻ ആരംഭിക്കുന്നു (സ്ട്രിംഗ് പ്രിഫിക്‌സ്)നൽകിയിരിക്കുന്ന സ്‌ട്രിംഗ് നിർദ്ദിഷ്ട പ്രിഫിക്‌സിൽ ആരംഭിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു. നിലവിലുണ്ടെങ്കിൽ ശരി നൽകുന്നുപ്രിഫിക്‌സ് - സ്‌ട്രിംഗിൽ പരിശോധിക്കാനുള്ള പ്രിഫിക്‌സ്
ബൂളിയൻ ആരംഭം (സ്ട്രിംഗ് പ്രിഫിക്‌സ്, ഇന്റന്റ് ടോഫ്സെറ്റ്)തന്നിരിക്കുന്ന സ്ട്രിംഗ് ടോഫ്സെറ്റ് പാരാമീറ്ററിനെ അടിസ്ഥാനമാക്കി നിർദ്ദിഷ്ട പ്രിഫിക്‌സിൽ ആരംഭിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു. നിലവിലുണ്ടെങ്കിൽ ശരി നൽകുന്നുപ്രിഫിക്‌സ് - സ്‌ട്രിംഗിൽ പരിശോധിക്കാനുള്ള പ്രിഫിക്‌സ്
tooffset - തിരയൽ ആരംഭിക്കേണ്ട സൂചിക
സ്ട്രിംഗ് സ്ട്രിപ്പ് ()മുൻ‌നിരയിലും പിന്നിലുമുള്ള എല്ലാ വൈറ്റ്‌സ്‌പെയ്‌സുകളും നീക്കംചെയ്‌ത ഒരു സ്‌ട്രിംഗ് നൽകുന്നു
സ്ട്രിംഗ് സ്ട്രിപ്പ് ലീഡിംഗ് ()എല്ലാ മുൻ‌നിര സ്‌പെയ്‌സുകളും നീക്കംചെയ്‌ത സ്‌ട്രിംഗിന്റെ ഒരു സബ്‌സ്ട്രിംഗ് നൽകുന്നു
സ്ട്രിംഗ് സ്ട്രിപ്പ് ട്രെയിലിംഗ് ()പുറകിലുള്ള എല്ലാ സ്‌പെയ്‌സുകളും നീക്കംചെയ്‌ത സ്‌ട്രിംഗിന്റെ ഒരു സബ്‌സ്ട്രിംഗ് നൽകുന്നു
CharSequence subSequence (int startIndex, int endIndex)ആരംഭ, അവസാന സൂചികയെ അടിസ്ഥാനമാക്കി സ്‌ട്രിംഗിന്റെ പ്രതീക ശ്രേണി നൽകുന്നുstartIndex - സബ്‌സ്ട്രിംഗ് വീണ്ടെടുക്കേണ്ട സൂചിക
endIndex - സബ്‌സ്ട്രിംഗ് വീണ്ടെടുക്കേണ്ട സൂചിക
സ്ട്രിംഗ് സബ് സ്ട്രിംഗ് (int startIndex)ആരംഭ സൂചികയെ അടിസ്ഥാനമാക്കി സ്ട്രിംഗിന്റെ ഒരു സബ്സ്ട്രിംഗ് നൽകുന്നുstartIndex - സബ്‌സ്ട്രിംഗ് വീണ്ടെടുക്കേണ്ട സൂചിക
സ്ട്രിംഗ് സബ് സ്ട്രിംഗ് (int startIndex, int endIndex)ആരംഭ, അവസാന സൂചികയെ അടിസ്ഥാനമാക്കി സ്ട്രിംഗിന്റെ ഒരു സബ്സ്ട്രിംഗ് നൽകുന്നുstartIndex - സബ്‌സ്ട്രിംഗ് വീണ്ടെടുക്കേണ്ട സൂചിക
endIndex - സബ്‌സ്ട്രിംഗ് വീണ്ടെടുക്കേണ്ട സൂചിക
char [] to CharArray ()സ്‌ട്രിംഗിനെ പ്രതീക അറേയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു
സ്ട്രിംഗ് ടു ലോവർ‌കേസ് ()സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും ചെറിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു
സ്ട്രിംഗ് ടു ലോവർ‌കേസ് (ലോക്കേൽ ലോക്കേൽ)ലോക്കേൽ നിയമങ്ങളെ അടിസ്ഥാനമാക്കി സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും ചെറിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നുഭാഷ - പ്രയോഗിക്കേണ്ട ലോക്കേൽ നിയമങ്ങൾ
സ്ട്രിംഗ് ടോററിംഗ് ()സ്ട്രിംഗ് തന്നെ നൽകുന്നു
സ്ട്രിംഗ് ടു അപ്പർ‌കേസ് ()സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും വലിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു
സ്ട്രിംഗ് ടു അപ്പർ‌കേസ് (ലോക്കേൽ ലോക്കേൽ)ലോക്കേൽ നിയമങ്ങളെ അടിസ്ഥാനമാക്കി സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും വലിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നുഭാഷ - പ്രയോഗിക്കേണ്ട ലോക്കേൽ നിയമങ്ങൾ
സ്ട്രിംഗ് ട്രിം ()മുൻ‌നിരയിലും പിന്നിലുമുള്ള എല്ലാ ഇടങ്ങളും നീക്കംചെയ്‌ത ഒരു സ്‌ട്രിംഗ് നൽകുന്നു
സ്ട്രിംഗ് ഫോർമാറ്റ്സ്ട്രിംഗ് (സ്ട്രിംഗ് ഫോർമാറ്റ്, ഒബ്ജക്റ്റ് ... ആർഗുകൾ)ഫോർമാറ്റും ആർഗ്യുമെന്റുകളും അടിസ്ഥാനമാക്കി ഫോർമാറ്റുചെയ്‌ത സ്‌ട്രിംഗ് നൽകുന്നുഫോർമാറ്റ് - ഫോർമാറ്റ് സ്പെസിഫയർ
args - ഫോർമാറ്റ് സ്‌പെസിഫയർ പരാമർശിച്ച ആർഗ്യുമെന്റുകൾ
സ്‌ട്രിംഗ് ജോയിൻ (CharSequence delimiter, CharSequence ... ഘടകങ്ങൾ)ഡിലിമിറ്റർ ഉപയോഗിച്ച് പ്രതീക ശ്രേണി ഘടകങ്ങളിൽ ചേരുന്നുഡിലിമിറ്റർ - ചേരാനുള്ള ഡിലിമിറ്റർ
ഘടകങ്ങൾ - ചേരുന്നതിനുള്ള സ്ട്രിംഗ് ഘടകങ്ങൾ
സ്ട്രിംഗ് മൂല്യംഓഫ് (ബൂളിയൻ ബി)ബൂളിയൻ ആർഗ്യുമെന്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നു. ശരി കടന്നുപോയാൽ, ശരിയാണ്b - ബൂലിയൻ മൂല്യം ശരി അല്ലെങ്കിൽ തെറ്റ്
സ്ട്രിംഗ് മൂല്യംഓഫ് (ചാർ സി)പ്രതീക ആർഗ്യുമെന്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നുc - പ്രതീകം
സ്ട്രിംഗ് മൂല്യംഓഫ് (ചാർ [] ഡാറ്റ)പ്രതീക അറേ ആർഗ്യുമെന്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നുഡാറ്റ - പ്രതീക ശ്രേണി
സ്ട്രിംഗ് മൂല്യംഓഫ് (ഇരട്ട d)ഇരട്ട ആർഗ്യുമെന്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നുd - ഇരട്ട മൂല്യം
സ്ട്രിംഗ് മൂല്യംഓഫ് (ഫ്ലോട്ട് എഫ്)ഫ്ലോട്ട് ആർഗ്യുമെന്റിന്റെ സ്ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നുf - ഫ്ലോട്ട് മൂല്യം
സ്ട്രിംഗ് മൂല്യംഓഫ് (int i)പൂർണ്ണസംഖ്യ ആർഗ്യുമെന്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നുi - സംഖ്യ മൂല്യം
സ്ട്രിംഗ് മൂല്യം IOf (നീളമുള്ള l)ദൈർഘ്യമേറിയ ആർഗ്യുമെന്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നുl - ദൈർഘ്യമേറിയ മൂല്യം
സ്ട്രിംഗ് മൂല്യംഓഫ് (ഒബ്ജക്റ്റ് ഒബ്ജക്റ്റ്)ഒബ്‌ജക്റ്റ് ആർഗ്യുമെന്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നുഒബ്ജക്റ്റ് - ഒബ്ജക്റ്റ്
സ്ട്രിംഗ് മൂല്യംഓഫ് (ചാർ [] ഡാറ്റ, ഇന്റൽ ഓഫ്സെറ്റ്, ഇന്റന്റ് എണ്ണം)ഓഫ്‌സെറ്റും എണ്ണവും അടിസ്ഥാനമാക്കി നിർദ്ദിഷ്‌ട സബ്‌സ്ട്രിംഗ് പ്രതീക അറേ ആർഗ്യുമെന്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്നുഡാറ്റ - പ്രതീക ശ്രേണി
ഓഫ്സെറ്റ് - സൂചിക ആരംഭിക്കുക
എണ്ണം - സബ്‌സ്ട്രിംഗിന്റെ നീളം

ഉദാഹരണം: അറേ പ്രതീകങ്ങളിൽ നിന്ന് ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കുന്നതിനുള്ള ജാവ പ്രോഗ്രാം

ചുവടെയുള്ള ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഒരു പരിവർത്തനം ചെയ്യുന്നു ശ്രേണി പുതിയ കീവേഡ് ഉപയോഗിച്ച് ജാവയിലെ ഒരു സ്ട്രിംഗിലേക്കുള്ള പ്രതീകങ്ങളുടെ.

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

ഉദാഹരണം: താരതമ്യം ടു (), കണ്ടന്റ്എക്വലുകൾ () എന്നിവ അടങ്ങിയിരിക്കുന്നു ()

ഈ ഉദാഹരണം ജാവയിലെ 2 സ്ട്രിംഗുകളുടെ താരതമ്യം കാണിക്കുന്നു

  1. ഇൻപുട്ട് സ്ട്രിംഗ് ആർഗ്യുമെന്റ് സ്ട്രിംഗിനെ വിജയിപ്പിക്കുന്നതിനാൽ താരതമ്യം ചെയ്യുക () ഇവിടെ ഒരു പോസിറ്റീവ് സംഖ്യ നൽകുന്നു.
  2. കേസ് പരിഗണിക്കാതെ തന്നെ രണ്ട് സ്ട്രിംഗുകളും തുല്യമായതിനാൽ താരതമ്യം ടൊഇഗ്നോർകേസ് () 0 നൽകുന്നു.
  3. ഇൻ‌പുട്ട് സ്‌ട്രിംഗിൽ‌ ആർ‌ഗ്യുമെൻറ് സ്‌ട്രിംഗ് അടങ്ങിയിരിക്കുന്നതിനാൽ‌ () ശരിയാണ്
  4. ഇൻപുട്ട് സ്‌ട്രിംഗിൽ കൃത്യമായ ആർഗ്യുമെന്റ് സ്‌ട്രിംഗ് അടങ്ങിയിട്ടില്ലാത്തതിനാൽ contentEquals () തെറ്റായി നൽകുന്നു.
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

ഉദാഹരണം: സമം ഉപയോഗിക്കുന്നത് ()

ഉള്ളടക്കം ഒന്നുതന്നെയാണെങ്കിലും കേസ് പൊരുത്തപ്പെടാത്തതിനാൽ ആദ്യ output ട്ട്‌പുട്ട് തെറ്റാണ്. ഉള്ളടക്കവും കേസും പൊരുത്തപ്പെടുന്നതിനാൽ രണ്ടാമത്തെ output ട്ട്‌പുട്ട് ശരിയാണ്.

രണ്ട് ഉള്ളടക്കവും വ്യത്യസ്‌തമായതിനാൽ മൂന്നാമത്തെ output ട്ട്‌പുട്ട് തെറ്റാണ്.

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 സ്ട്രിംഗുകൾ സംയോജിപ്പിക്കാനും കഴിയും. വ്യക്തമാക്കിയ ഡിലിമിറ്റർ ഉപയോഗിച്ച് ആർഗ്യുമെന്റിൽ നൽകിയ വാക്കുകളിൽ ഇത് ചേരും.

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 ആയി വ്യക്തമാക്കുക, അതായത് ഇത് രണ്ട് സ്ട്രിംഗ് അറേ മൂല്യങ്ങളായി വിഭജിക്കുന്നു.

മാറ്റിസ്ഥാപിക്കുന്നതിനുള്ള ആദ്യ ഉദാഹരണത്തിൽ, ഞങ്ങൾ വ്യക്തിഗത പ്രതീകത്തെ മാറ്റിസ്ഥാപിക്കുന്നു. അടുത്തതിൽ, ഞങ്ങൾ പ്രതീക ശ്രേണി മാറ്റിസ്ഥാപിക്കുന്നു.

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

തീരുമാനം

ഈ ട്യൂട്ടോറിയലിൽ, ജാവയിലെ സ്ട്രിംഗിനെക്കുറിച്ചും അത് സൃഷ്ടിക്കുന്നതിനുള്ള വ്യത്യസ്ത വഴികളെക്കുറിച്ചും ഉദാഹരണങ്ങളോടൊപ്പം വ്യത്യസ്ത സ്ട്രിംഗ് രീതികളെക്കുറിച്ചും നിങ്ങൾ പഠിച്ചു.

അവലംബം