జావాలోని స్ట్రింగ్‌లను సూచించడానికి క్లాస్ java.lang.Stringఉపయోగించబడుతుంది. జావాలోని స్ట్రింగ్‌లు మార్పులేనివి, అంటే స్ట్రింగ్ ఆబ్జెక్ట్ సృష్టించబడిన తర్వాత, దాని కంటెంట్‌లు మార్చబడవు.
స్ట్రింగ్ ఆబ్జెక్ట్‌ను సృష్టిస్తోంది:
జావాలో స్ట్రింగ్ ఆబ్జెక్ట్‌ను సృష్టించడానికి రెండు మార్గాలు ఉన్నాయి:
- స్ట్రింగ్ అక్షరాలను ఉపయోగించడం:
జావాString str1 = "Hello"; // Creating a string using string literals
- కీవర్డ్‌ని ఉపయోగించడం
new:
జావాString str2 = new String("Hello"); // Creating a string using the new keyword
స్ట్రింగ్ పద్ధతులు:
క్లాస్ Stringస్ట్రింగ్స్‌తో పనిచేయడానికి అనేక ఉపయోగకరమైన పద్ధతులను అందిస్తుంది. ఇక్కడ కొన్ని సాధారణంగా ఉపయోగించే పద్ధతులు ఉన్నాయి:
length(): స్ట్రింగ్ పొడవును అందిస్తుంది.
జావాString str = "Hello";
int len = str.length(); // len = 5charAt(index): స్ట్రింగ్‌లో పేర్కొన్న సూచిక వద్ద అక్షరాన్ని అందిస్తుంది.
జావాString str = "Hello";
char c = str.charAt(0); // c = 'H'substring(startIndex): పేర్కొన్న సూచిక నుండి ప్రారంభమయ్యే స్ట్రింగ్ యొక్క సబ్‌స్ట్రింగ్‌ను అందిస్తుంది.
జావాString str = "Hello";
String subStr = str.substring(1); // subStr = "ello"substring(startIndex, endIndex): ప్రారంభ సూచిక నుండి ప్రారంభమయ్యే మరియు ముగింపు సూచిక - 1లో ముగిసే స్ట్రింగ్ యొక్క సబ్‌స్ట్రింగ్‌ను అందిస్తుంది.
జావాString str = "Hello";
String subStr = str.substring(1, 4); // subStr = "ell"toUpperCase(): స్ట్రింగ్‌ను పెద్ద అక్షరంలో చూపుతుంది.
జావాString str = "Hello";
String upperStr = str.toUpperCase(); // upperStr = "HELLO"toLowerCase(): స్ట్రింగ్‌ను చిన్న అక్షరంలో చూపుతుంది.
జావాString str = "Hello";
String lowerStr = str.toLowerCase(); // lowerStr = "hello"replace(oldChar, newChar): పాతచార్ యొక్క అన్ని సంఘటనలను స్ట్రింగ్‌లోని కొత్తచార్‌తో భర్తీ చేస్తుంది.
జావాString str = "Hello";
String newStr = str.replace('l', 'w'); // newStr = "Hewwo"trim(): లీడింగ్ మరియు ట్రైలింగ్ వైట్‌స్పేస్ తీసివేయబడిన స్ట్రింగ్‌ను అందిస్తుంది.
జావాString str = " Hello ";
String trimmedStr = str.trim(); // trimmedStr = "Hello"తీగలను పోల్చడం:
జావాలోని రెండు స్ట్రింగ్ ఆబ్జెక్ట్‌లను పోల్చడానికి, మీరు equals()స్ట్రింగ్‌ల కంటెంట్‌లను పోల్చే పద్ధతిని ఉపయోగించవచ్చు. compareTo()మీరు తీగలను లెక్సికోగ్రాఫికల్‌గా పోల్చే పద్ధతిని కూడా ఉపయోగించవచ్చు (అంటే, వాటి నిఘంటువు క్రమం ఆధారంగా).
జావాString str1 = "Hello";
String str2 = "Hello";
boolean equal = str1.equals(str2); // equal = true
String str3 = "World";
int compareResult = str1.compareTo(str3); // compareResult < 0==స్ట్రింగ్ ఆబ్జెక్ట్‌లను పోల్చడానికి మీరు ఆపరేటర్‌ను ఉపయోగించకూడదని గమనించండి , ఎందుకంటే ఇది స్ట్రింగ్‌ల కంటెంట్‌లతో కాకుండా ఆబ్జెక్ట్ రిఫరెన్స్‌లను పోల్చింది.
2. String Methods స్ట్రింగ్ మెథడ్స్ పట్టిక
ఖచ్చితంగా, జావాలో సాధారణంగా ఉపయోగించే స్ట్రింగ్ పద్ధతుల పట్టిక ఇక్కడ ఉంది:
| పద్ధతి | వివరణ |
|---|---|
charAt(int index) | పేర్కొన్న సూచికలో అక్షరాన్ని అందిస్తుంది |
concat(String str) | పేర్కొన్న స్ట్రింగ్‌ను ఇన్వోకింగ్ స్ట్రింగ్ చివరి వరకు సంగ్రహిస్తుంది |
equals(Object obj) | ఇన్వోకింగ్ స్ట్రింగ్‌ను పేర్కొన్న వస్తువుతో పోలుస్తుంది |
equalsIgnoreCase(String str) | కేస్ పరిశీలనలను విస్మరిస్తూ, ఇన్వోకింగ్ స్ట్రింగ్‌ని పేర్కొన్న స్ట్రింగ్‌తో పోలుస్తుంది |
indexOf(int ch) | పేర్కొన్న అక్షరం యొక్క మొదటి సంఘటన యొక్క సూచికను అందిస్తుంది |
indexOf(int ch, int fromIndex) | పేర్కొన్న సూచిక నుండి ప్రారంభించి, పేర్కొన్న అక్షరం యొక్క మొదటి సంఘటన యొక్క సూచికను అందిస్తుంది |
indexOf(String str) | పేర్కొన్న స్ట్రింగ్ యొక్క మొదటి సంఘటన యొక్క సూచికను అందిస్తుంది |
indexOf(String str, int fromIndex) | పేర్కొన్న సూచిక నుండి ప్రారంభించి, పేర్కొన్న స్ట్రింగ్ యొక్క మొదటి సంఘటన యొక్క సూచికను అందిస్తుంది |
length() | స్ట్రింగ్ పొడవును అందిస్తుంది |
replace(char oldChar, char newChar) | oldCharదీనితో అన్ని సంఘటనలను భర్తీ చేయడం వలన కొత్త స్ట్రింగ్‌ను అందిస్తుందిnewChar |
replaceAll(String regex, String replacement) | ఇవ్వబడిన సాధారణ వ్యక్తీకరణకు ఇచ్చిన భర్తీతో సరిపోలే ఇన్వోకింగ్ స్ట్రింగ్‌లోని ప్రతి సబ్‌స్ట్రింగ్‌ను భర్తీ చేస్తుంది |
split(String regex) | అందించిన సాధారణ వ్యక్తీకరణ ఆధారంగా ఇన్వోకింగ్ స్ట్రింగ్‌ను సబ్‌స్ట్రింగ్‌ల శ్రేణిగా విభజిస్తుంది |
startsWith(String prefix) | ఇన్వోకింగ్ స్ట్రింగ్ పేర్కొన్న ప్రిఫిక్స్‌తో ప్రారంభమైతే పరీక్షిస్తుంది |
substring(int beginIndex) | పేర్కొన్న ఇండెక్స్ నుండి ప్రారంభించి, ఇన్వోకింగ్ స్ట్రింగ్ యొక్క సబ్‌స్ట్రింగ్‌ను అందిస్తుంది |
substring(int beginIndex, int endIndex) | పేర్కొన్న ప్రారంభ సూచిక నుండి ప్రారంభించి, పేర్కొన్న ముగింపు సూచికలో ముగిసేలా ఇన్వోకింగ్ స్ట్రింగ్ యొక్క సబ్‌స్ట్రింగ్‌ను అందిస్తుంది |
toLowerCase() | చిన్న అక్షరంలోని అన్ని అక్షరాలతో కొత్త స్ట్రింగ్‌ను అందిస్తుంది |
toUpperCase() | పెద్ద అక్షరంలోని అన్ని అక్షరాలతో కొత్త స్ట్రింగ్‌ను అందిస్తుంది |
trim() | లీడింగ్ మరియు ట్రైలింగ్ వైట్‌స్పేస్‌లు తీసివేయబడిన కొత్త స్ట్రింగ్‌ను అందిస్తుంది |
ఇది జావాలో అందుబాటులో ఉన్న అన్ని స్ట్రింగ్ పద్ధతుల యొక్క సమగ్ర జాబితా కాదని గమనించండి. జావా స్ట్రింగ్ క్లాస్‌లో ఇంకా చాలా పద్ధతులు అందుబాటులో ఉన్నాయి....
