జావా రెగ్యులర్ ఎక్స్‌ప్రెషన్ - ప్రోగ్రామింగ్ ఉదాహరణలు
సాధారణ వ్యక్తీకరణలు జావాలో నమూనా సరిపోలిక కోసం శక్తివంతమైన సాధనం. ఈ కథనంలో, జావాలో సాధారణ వ్యక్తీకరణలను ఎలా ఉపయోగించాలో ప్రదర్శించడానికి మేము ప్రోగ్రామింగ్ ఉదాహరణలను అందిస్తాము.
స్ట్రింగ్‌ను సరిపోల్చడం
సాధారణ ఎక్స్‌ప్రెషన్‌ల కోసం సరళమైన వినియోగ సందర్భం స్ట్రింగ్‌ను నమూనాకు వ్యతిరేకంగా సరిపోల్చడం. కింది కోడ్ సాధారణ వ్యక్తీకరణకు వ్యతిరేకంగా స్ట్రింగ్‌ను ఎలా సరిపోల్చాలో చూపుతుంది:
జావాimport java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexExample {
public static void main(String[] args) {
String input = "Hello, World!";
String pattern = "Hello, .*!";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(input);
if (m.matches()) {
System.out.println("Match found.");
} else {
System.out.println("No match found.");
}
}
}
ఈ ఉదాహరణలో, మేము ముందుగా ఒక ఇన్‌పుట్ స్ట్రింగ్ మరియు దానికి సరిపోయే నమూనాను నిర్వచించాము. మేము Pattern.compile() పద్ధతిని ఉపయోగించి ఒక నమూనా వస్తువును మరియు నమూనా ఆబ్జెక్ట్ యొక్క Matcher() పద్ధతిని ఉపయోగించి మ్యాచర్ ఆబ్జెక్ట్‌ను సృష్టిస్తాము. ఇన్‌పుట్ స్ట్రింగ్ నమూనాతో సరిపోతుందో లేదో తెలుసుకోవడానికి మేము మ్యాచర్ ఆబ్జెక్ట్ యొక్క మ్యాచ్‌లు() పద్ధతిని ఉపయోగిస్తాము.
సమూహాలను సరిపోల్చడం మరియు సంగ్రహించడం
స్ట్రింగ్ నుండి అక్షరాల సమూహాలను సరిపోల్చడానికి మరియు సంగ్రహించడానికి కూడా రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లను ఉపయోగించవచ్చు. స్ట్రింగ్ నుండి సమూహాలను ఎలా సరిపోల్చాలి మరియు సంగ్రహించాలో క్రింది కోడ్ ప్రదర్శిస్తుంది:
జావాimport java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexExample {
public static void main(String[] args) {
String input = "John Smith, 42 years old";
String pattern = "(\\w+) (\\w+), (\\d+) years old";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(input);
if (m.matches()) {
String firstName = m.group(1);
String lastName = m.group(2);
int age = Integer.parseInt(m.group(3));
System.out.println("Name: " + firstName + " " + lastName);
System.out.println("Age: " + age);
} else {
System.out.println("No match found.");
}
}
}
ఈ ఉదాహరణలో, మేము మొదట ఇన్‌పుట్ స్ట్రింగ్‌ను మరియు మూడు సమూహాలను కలిగి ఉన్న నమూనాను నిర్వచించాము: మొదటి మరియు చివరి పేర్లు మరియు వయస్సు. అప్పుడు మనం మునుపటిలాగా ఒక Pattern object మరియు Matcher ఆబ్జెక్ట్‌ని సృష్టిస్తాము. మేము ఇన్‌పుట్ స్ట్రింగ్ నుండి సమూహాల విలువలను సంగ్రహించడానికి మ్యాచర్ ఆబ్జెక్ట్ యొక్క సమూహం() పద్ధతిని ఉపయోగిస్తాము.
వచనాన్ని భర్తీ చేస్తోంది
స్ట్రింగ్‌లోని వచనాన్ని భర్తీ చేయడానికి రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లను కూడా ఉపయోగించవచ్చు. కింది కోడ్ సాధారణ వ్యక్తీకరణను ఉపయోగించి వచనాన్ని ఎలా భర్తీ చేయాలో చూపుతుంది:
జావాimport java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexExample {
public static void main(String[] args) {
String input = "The quick brown fox jumps over the lazy dog.";
String pattern = "\\s+";
String replacement = "-";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(input);
String output = m.replaceAll(replacement);
System.out.println("Input: " + input);
System.out.println("Output: " + output);
}
}
ఈ ఉదాహరణలో, మేము ముందుగా ఒక ఇన్‌పుట్ స్ట్రింగ్ మరియు దానికి సరిపోయే నమూనాను నిర్వచించాము. అప్పుడు మనం మునుపటిలాగా ఒక Pattern object మరియు Matcher ఆబ్జెక్ట్‌ని సృష్టిస్తాము. మేము ఇన్‌పుట్ స్ట్రింగ్‌లోని నమూనా యొక్క అన్ని సరిపోలికలను రీప్లేస్‌మెంట్ టెక్స్ట్‌తో భర్తీ చేయడానికి మ్యాచర్ ఆబ్జెక్ట్ యొక్క రీప్లేస్‌అల్() పద్ధతిని ఉపయోగిస్తాము. మేము అసలు ఇన్‌పుట్ స్ట్రింగ్ మరియు సవరించిన అవుట్‌పుట్ స్ట్రింగ్‌ను ప్రింట్ చేస్తాము.
