Java Developersලට Regex: Text සැකසීම හරි ලේසියි!

ආයුබෝවන් හැමෝටම! කොහොමද ඉතින්? අද අපි කතා කරන්න යන්නේ ගොඩක් අයව ටිකක් අවුල් කරන, ඒත් එක පාරක් තේරුම් ගත්තම වැඩේ හරි ලේසි කරන, 'Regular Expressions' නැත්නම් කෙටියෙන් 'Regex' ගැනයි.

Java වල Programming කරන අපිට Text Processing කියන්නේ නිතරම වගේ එන වැඩක්. User input validate කරනවාද, Log file analyse කරනවාද, Database එකකින් ගත්ත data clean කරනවාද, මේ හැම තැනකම වගේ Text එක්ක තමයි වැඩ කරන්න වෙන්නේ.

හිතන්නකෝ, ඔයාට ඕනේ User කෙනෙක් Email එකක් හරියටම ටයිප් කරලද කියලා බලන්න, එහෙම නැත්නම් ලංකාවේ Phone Number එකක Format එක හරියට තියනවද කියලා බලන්න. මේ වගේ වෙලාවට සාමාන්‍ය String manipulation methods වලින් විතරක් ගොඩයන්න අමාරුයි. අන්න ඒ වෙලාවට තමයි අපේ Hero, Regex එළියට එන්නේ!

අද අපි බලමු Regex කියන්නේ මොනවද, Java වල ඒවා කොහොමද පාවිච්චි කරන්නේ, ඒ වගේම අපේ දිනපතා වැඩ වලට මේවා කොච්චර ප්‍රයෝජනවත්ද කියලා.

Regex කියන්නේ මොනවද?

සරලව කිව්වොත්, Regular Expression (Regex) කියන්නේ Text Patterns විස්තර කරන්න පාවිච්චි කරන බලගතු String sequence එකක්. මේක හරියට පොලිසියේ අයට සැකකරුවෙක් හොයන්න Sketches අඳිනවා වගේ වැඩක්. අපි Sketches වලින් සැකකරුවගේ විස්තර දෙනවා වගේ, Regex වලින් අපි Pattern එකක විස්තර දෙනවා.

Regex වලින් අපිට පුළුවන්:

• Strings වල නිශ්චිත Patterns හොයන්න (Searching)
• Patterns වලට අදාල කොටස් වෙනස් කරන්න (Replacing)
• Inputs වල Format එක හරියට තියනවද කියලා බලන්න (Validating)

Data validation, parsing log files, text scraping වගේ ගොඩක් වැඩ වලට මේවා හරිම වැදගත්.

Java වල Regex පාවිච්චි කරන්නේ කොහොමද?

Java වල Regular Expressions handle කරන්න java.util.regex package එක තියෙනවා. මේ package එකේ ප්‍රධාන Class දෙකක් තියෙනවා: Pattern සහ Matcher.

• Pattern Class: මේකෙන් කරන්නේ Regex Pattern එකක් compile කරන එක. මේක String එකකින් Pattern Object එකක් හදනවා.
• Matcher Class: මේකෙන් කරන්නේ Compile කරපු Pattern එකක් දීලා, ඒ Pattern එක String එකක match වෙනවද කියලා බලන එක.

උදාහරණයක්: Simple Pattern Matching

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class RegexBasics {
    public static void main(String[] args) {
        String text = "අපේ රට ශ්‍රී ලංකාව.";
        String pattern = "ශ්‍රී ලංකාව";

        // Pattern.matches() method එක whole String එකටම match එකක් බලනවා
        // මේකෙන් String එකේ කොටසක් match වෙන්නේ නැහැ.
        boolean exactMatch = Pattern.matches(pattern, text); 
        System.out.println("Exact match for whole string: " + exactMatch); // Output: false

        // Substring match එකක් හොයන්න Pattern සහ Matcher පාවිච්චි කරන විදිය
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(text);

        if (m.find()) { // find() method එක String එකේ කොහේ හරි Pattern එකක් තියනවද කියලා බලනවා
            System.out.println("Substring found: " + m.group()); // Output: Substring found: ශ්‍රී ලංකාව
        } else {
            System.out.println("No substring match found.");
        }
    }
}

මේ Code එකෙන් ඔයාලට පේනවා ඇති, Pattern.matches() කියන්නේ whole String එකටම Pattern එක match වෙනවද කියලා බලන එක. නමුත් සාමාන්‍යයෙන් අපිට ඕන වෙන්නේ String එකේ කොටසකට Pattern එක match වෙනවද කියලා බලන්න. ඒකට තමයි Pattern.compile() කරලා Matcher Object එකක් හදලා m.find() පාවිච්චි කරන්නේ. m.group() එකෙන් match වුන කොටස ලබාගන්න පුළුවන්.

මූලික Regex Syntax

Regex වල syntax එක මුලින් ටිකක් අමුතු වගේ පෙනුනත්, මේ මූලික Symbols ටික තේරුම් ගත්තාම වැඩේ හරි ලේසියි.

• Literal Characters: සාමාන්‍ය Characters (A, a, B, b, 1, 2, 3) ඒ විදියටම Match වෙනවා. "apple" කියන Regex එකෙන් "apple" කියන String එකම Match වෙනවා.
• Metacharacters: මේවාට විශේෂ තේරුමක් තියෙනවා.
  • . (Dot): Newline character එක ඇරෙන්න ඕනෑම character එකක් Match කරනවා.
  • \d: ඕනෑම digit එකක් (0-9). [0-9] වගේමයි.
  • \D: Digit එකක් නොවන ඕනෑම character එකක්. [^0-9] වගේමයි.
  • \w: Word character එකක් (a-z, A-Z, 0-9, සහ underscore _). [a-zA-Z0-9_] වගේමයි.
  • \W: Word character එකක් නොවන ඕනෑම character එකක්.
  • \s: Whitespace character එකක් (space, tab, newline, carriage return).
  • \S: Whitespace character එකක් නොවන ඕනෑම character එකක්.
  • ^: String එකේ ආරම්භය Match කරනවා.
  • $: String එකේ අවසානය Match කරනවා.
  • [ ] (Character Sets): වර්ග වරහන් ඇතුලේ තියෙන ඕනෑම character එකක් Match කරනවා. [abc] කියන්නේ a, b, හෝ c. [a-z] කියන්නේ a ඉඳන් z දක්වා ඕනෑම character එකක්. [^abc] කියන්නේ a, b, c නොවන ඕනෑම character එකක්.
  • | (OR): එක් Pattern එකක් හෝ තව Pattern එකක් Match කරන්න. "cat|dog" කියන්නේ "cat" හෝ "dog".
  • ( ) (Grouping): Pattern එකේ කොටසක් Group කරන්න.
  • \ (Escape Character): Metacharacter එකක් Literal character එකක් විදියට Match කරන්න ඕන වුනාම පාවිච්චි කරනවා. උදාහරණයක් විදියට, . (dot) එකක් Match කරන්න ඕන නම් \. කියලා දෙන්න ඕනේ.
• Quantifiers: මේවායින් කලින් ආපු character එකක් හෝ Group එකක් කී වතාවක් Match වෙන්න ඕනෙද කියලා කියනවා.
  • *: බිංදුවක් හෝ ඊට වැඩිය (Zero or more occurrences). "a*" කියන්නේ "", "a", "aa", "aaa"...
  • +: එකක් හෝ ඊට වැඩිය (One or more occurrences). "a+" කියන්නේ "a", "aa", "aaa"...
  • ?: බිංදුවක් හෝ එකක් (Zero or one occurrence). "colou?r" කියන්නේ "color" හෝ "colour".
  • {n}: හරියටම n වතාවක්. "a{3}" කියන්නේ "aaa".
  • {n,}: n වතාවක් හෝ ඊට වැඩිය. "a{2,}" කියන්නේ "aa", "aaa"...
  • {n,m}: n සහ m අතර වතාවක්. "a{2,4}" කියන්නේ "aa", "aaa", හෝ "aaaa".

මේ Symbols ටික තේරුම් ගත්තාම, ඕනෑම Pattern එකක් හදාගන්න පුළුවන්.

ප්‍රායෝගික උදාහරණ

දැන් අපි බලමු මේ Regex අපේ Real-world Scenarios වලට කොහොමද පාවිච්චි කරන්නේ කියලා.

1. Email Address Validation

Email address එකක Format එක හරියට තියනවද කියලා Validate කරන්න Regex හරිම ප්‍රයෝජනවත්.

import java.util.regex.Pattern;

public class EmailValidator {
    public static void main(String[] args) {
        String email1 = "[email protected]";
        String email2 = "invalid-email";
        String email3 = "[email protected]";

        // Email Validation Regex: [A-Za-z0-9+_.-]+@([A-Za-z0-9-]+\.)+[A-Za-z]{2,6}$
        // user: [A-Za-z0-9+_.-]+
        // @ symbol: @
        // domain: ([A-Za-z0-9-]+\.)+
        // top-level domain: [A-Za-z]{2,6}
        String emailRegex = "^[A-Za-z0-9+_.-]+@([A-Za-z0-9-]+\\.)+[A-Za-z]{2,6}$";
        
        System.out.println("\nEmail Validation:");
        System.out.println(email1 + " is " + (Pattern.matches(emailRegex, email1) ? "valid" : "invalid"));
        System.out.println(email2 + " is " + (Pattern.matches(emailRegex, email2) ? "valid" : "invalid"));
        System.out.println(email3 + " is " + (Pattern.matches(emailRegex, email3) ? "valid" : "invalid"));
    }
}

මේ Regex එකෙන් [email protected] වගේ Format එකක් Check කරනවා. [A-Za-z0-9+_.-]+ කියන්නේ @ එකට කලින් තියෙන user name එකේ Letters, Numbers, Plus, Underscore, Dot, Hyphen Match කරනවා. @ එකෙන් Email එකේ @ Symbol එක Match කරනවා. ([A-Za-z0-9-]+\\.)+ කියන්නේ Domain Name එක Match කරනවා (sub.domain.com වගේ). [A-Za-z]{2,6}$ කියන්නේ top-level domain එක Match කරනවා (com, org, lk වගේ).

2. Sri Lankan Phone Number Validation

ලංකාවේ Phone Number Format දෙකක් ප්‍රධාන වශයෙන් තියෙනවා: Landline Numbers (0XX-XXXXXXX) සහ Mobile Numbers (07X-XXXXXXX). මේ දෙකම Validate කරන්න පුළුවන් Regex එකක් හදමු.

import java.util.regex.Pattern;

public class PhoneNumberValidator {
    public static void main(String[] args) {
        String phone1 = "077-1234567"; // Mobile
        String phone2 = "011-9876543"; // Landline
        String phone3 = "123-4567890"; // Invalid (wrong prefix)
        String phone4 = "0711234567"; // Invalid (missing hyphen)

        // Sri Lankan Phone Number Regex
        // ^(0\\d{2}-\\d{7}|07\\d-\\d{7})$
        // (0\\d{2}-\\d{7}) for Landlines like 011-xxxxxxx
        // (07\\d-\\d{7}) for Mobiles like 077-xxxxxxx
        String phoneRegex = "^(0\\d{2}-\\d{7}|07\\d-\\d{7})$";
        
        System.out.println("\nSri Lankan Phone Number Validation:");
        System.out.println(phone1 + " is " + (Pattern.matches(phoneRegex, phone1) ? "valid" : "invalid"));
        System.out.println(phone2 + " is " + (Pattern.matches(phoneRegex, phone2) ? "valid" : "invalid"));
        System.out.println(phone3 + " is " + (Pattern.matches(phoneRegex, phone3) ? "valid" : "invalid"));
        System.out.println(phone4 + " is " + (Pattern.matches(phoneRegex, phone4) ? "valid" : "invalid"));
    }
}

^ සහ $ වලින් String එකේ මුල සහ අග Exact Match කරන්න බලනවා. | වලින් Landline හෝ Mobile Pattern එකක් Match කරන්න කියනවා. \d{7} කියන්නේ හරියටම Digits හතක් Match කරන්න කියන එක. Java වලදී Regex String එකක් ඇතුලේ \ double කරන්න ඕනේ (\\d).

3. Extracting Numbers from Text

Text එකක තියෙන எல்லா numbers ටිකක් extract කරගන්නත් Regex පාවිච්චි කරන්න පුළුවන්.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class NumberExtractor {
    public static void main(String[] args) {
        String article = "මේ Article එකේ අංක ගොඩක් තියෙනවා. 2024 අවුරුද්දේ 123ක් විතර මේක කියවයි. මිලියන 10ක් වුනත් කියවන්න පුළුවන්.";
        Pattern numberPattern = Pattern.compile("\\d+");
        Matcher numberMatcher = numberPattern.matcher(article);
        System.out.println("\nNumbers found in text:");
        while (numberMatcher.find()) {
            System.out.println("Found: " + numberMatcher.group());
        }
    }
}

"\\d+" කියන්නේ එකක් හෝ ඊට වැඩියි Digits Match කරන්න කියන එක. while (numberMatcher.find()) Loop එකෙන් Text එකේ තියෙන හැම Number එකක්ම හොයලා print කරනවා.

4. Replacing Text

String Class එකේ තියෙන replaceAll() Method එකත් Regex පාවිච්චි කරනවා. මේකෙන් පුළුවන් Pattern එකකට අදාළ Text එකක් වෙනත් Text එකකින් Replace කරන්න.

public class TextReplacer {
    public static void main(String[] args) {
        String messyText = "මේ       පැරණි      Text    එකක්.   ගොඩක් spaces තියෙනවා.";
        // Multiple spaces with single space replacement
        String cleanedText = messyText.replaceAll("\\s+", " ");
        System.out.println("\nText Replacement:");
        System.out.println("Original: '" + messyText + "'");
        System.out.println("Cleaned: '" + cleanedText + "'");
    }
}

"\\s+" කියන්නේ එකක් හෝ ඊට වැඩියි Whitespace characters Match කරන්න කියන එක. මේකෙන් Messy String එකේ තියෙන Extra Spaces ඔක්කොම Single Space එකකින් Replace වෙනවා.

Regex Tips සහ Gotchas

Regex පාවිච්චි කරනකොට මතක තියාගන්න ඕනේ පොඩි Tips ටිකක් සහ පොඩ්ඩක් පරිස්සම් වෙන්න ඕනේ තැන් කිහිපයක් තියෙනවා.

• Performance: Complex Regex Patterns Slow වෙන්න පුළුවන්. විශේෂයෙන්ම ගොඩක් විශාල Text Data එක්ක වැඩ කරනකොට. පුළුවන් තරම් Simple Patterns පාවිච්චි කරන්න බලන්න.
• Escaping Special Characters: ., *, +, ?, [, ], (, ), {, }, \, ^, $ වගේ Symbols වලට Regex වලදී විශේෂ තේරුමක් තියෙනවා. ඔයාට මේ Symbols Literal විදියටම Match කරන්න ඕන නම්, ඒවාට කලින් \ (double backslash in Java String) එකක් දාන්න ඕනේ. උදාහරණයක් විදියට, "www.example.com" වගේ String එකක . එක Match කරන්න "www\\.example\\.com" කියලා දෙන්න ඕනේ.
• Greediness vs. Reluctance: By default, Quantifiers (*, +, ?, {}) "greedy" තමයි. ඒ කියන්නේ ඒවා Match කරන්න පුළුවන් දිගම String එක Match කරනවා. සමහර වෙලාවට අපිට ඕනේ කෙටිම Match එකක්. ඒකට Quantifier එකට පස්සේ ? එකක් දාන්න පුළුවන්. එතකොට ඒවා "reluctant" වෙනවා.

උදාහරණය: HTML Tag එකක් Match කිරීම.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class RegexGreedy {
    public static void main(String[] args) {
        String html = "<b>Bold</b> and <i>Italic</i>";

        // Greedy quantifier: matches the longest possible string
        Pattern p1 = Pattern.compile("<.*>"); 
        Matcher m1 = p1.matcher(html);
        System.out.println("\nGreedy Match:");
        while (m1.find()) {
            System.out.println("Found: " + m1.group()); // Output: Found: <b>Bold</b> and <i>Italic</i>
        }

        // Reluctant quantifier: matches the shortest possible string
        Pattern p2 = Pattern.compile("<.*?>"); 
        Matcher m2 = p2.matcher(html);
        System.out.println("\nReluctant Match:");
        while (m2.find()) {
            System.out.println("Found: " + m2.group()); // Output: Found: <b>, Found: </b>, Found: <i>, Found: </i>
        }
    }
}

<.*> කියන්නේ මුලින්ම එන < එකේ ඉඳන් අන්තිමටම එන > එක දක්වාම Match කරනවා. නමුත් <.*?> කියන්නේ < එකේ ඉඳන් ළඟම තියෙන > එක දක්වා Match කරනවා. මේ වෙනස ගොඩක් වැදගත් වෙන්න පුළුවන්.

අවසන් වශයෙන්...

ඉතින් යාළුවනේ, මේ Regex කියන්නේ Programming වලදි අපිට ගොඩක් දේවල් ලේසි කරගන්න උදව් වෙන, හරිම බලගතු Tool එකක්. මුලින් ටිකක් අමාරු වගේ පෙනුනත්, පොඩි පොඩි Patterns ටිකක් තේරුම් අරන් පුරුදු වුනාම, වැඩේ හරිම ලස්සනට කරගන්න පුළුවන්.

මතක තියාගන්න, Regex master කරන්න තියෙන හොඳම විදිය තමයි පුහුණුව. Online Regex Testers (regex101.com, regexr.com) වගේ ඒවා පාවිච්චි කරලා අත්හදා බලන්න. ඔයාලට පුළුවන් මේ Article එකේ Codes ටික Copy කරගෙන, තව Patterns හදලා, Test කරලා බලන්න.

ඔයාලට මේ Article එකෙන් අලුත් දෙයක් ඉගෙනගන්න ලැබුණාද? නැත්නම් Regex ගැන වෙන මොනවා හරි දැනගන්න ඕනෙද? පහලින් comment කරන්න. අපි ලබන Article එකෙන් හමුවෙමු! සුභ දවසක්!