Alternation এবং Grouping

যখন আমরা Java Regular Expressions (Regex) বা Reflection এর মধ্যে Alternation এবং Grouping সম্পর্কে আলোচনা করি, তখন আমরা দুটি আলাদা বিষয়ের মধ্যে পার্থক্য বুঝতে পারি। Alternation এবং Grouping মূলত Regex (Regular Expressions) এর গুরুত্বপূর্ণ ধারণা, যা java.util.regex প্যাকেজের মাধ্যমে ব্যবহার করা হয়।

এখানে আমরা Alternation এবং Grouping এর ব্যাখ্যা করব এবং দেখাবো কিভাবে Reflection এর মাধ্যমে রেগুলার এক্সপ্রেশন ব্যবহার করা হয়।

Alternation (বিকল্প/OR) in Regular Expressions

Alternation হল একটি রেগুলার এক্সপ্রেশন অপারেটর যা দুইটি বা তার বেশি প্যাটার্নের মধ্যে অথবা (OR) সম্পর্ক স্থাপন করে। এটি | (পাইপ সাইন) চিহ্নের মাধ্যমে প্রকাশ করা হয়।

• Alternation ব্যবহার করা হয় যখন আপনি দুটি বা তার বেশি প্যাটার্নের মধ্যে একটি মেলা খুঁজতে চান।
• উদাহরণস্বরূপ, "apple" অথবা "banana" খোঁজার জন্য রেগুলার এক্সপ্রেশন "apple|banana" ব্যবহার করা যেতে পারে।

Alternation এর উদাহরণ

import java.util.regex.*;

public class AlternationExample {
    public static void main(String[] args) {
        // Regular expression pattern using alternation (OR)
        String regex = "apple|banana";  // Match either "apple" or "banana"

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regex);

        // Sample text to be matched
        String text = "I like apple and banana.";

        // Create a matcher object
        Matcher matcher = pattern.matcher(text);

        // Find the match
        while (matcher.find()) {
            System.out.println("Found match: " + matcher.group());
        }
    }
}

ব্যাখ্যা:

• এখানে "apple|banana" প্যাটার্নটি স্ট্রিংয়ে "apple" বা "banana" যেকোনো একটি খুঁজবে।
• matcher.find() দিয়ে যদি "apple" বা "banana" থাকে, তবে তা মেলা হিসাবে আউটপুট হবে।

আউটপুট:

Found match: apple
Found match: banana

Grouping in Regular Expressions

Grouping রেগুলার এক্সপ্রেশনে এমন একটি বৈশিষ্ট্য যা প্যাটার্নের একটি অংশকে একত্রিত করে এবং সেগুলোর মধ্যে আলাদা আলাদা গ্রুপ তৈরি করে। গ্রুপিং সাধারণত () (প্যারেনথেসিস) চিহ্নের মাধ্যমে করা হয়।

• Grouping ব্যবহার করে আপনি প্যাটার্নের অংশগুলোকে আলাদা আলাদা ভাগে ভাগ করতে পারেন এবং পরে প্রতিটি গ্রুপের মান আলাদাভাবে অ্যাক্সেস করতে পারেন।
• উদাহরণস্বরূপ, একটি ডেটার ফরম্যাটের মধ্যে দিন, মাস এবং বছর আলাদা গ্রুপে ভাগ করা যায়।

Grouping এর উদাহরণ

import java.util.regex.*;

public class GroupingExample {
    public static void main(String[] args) {
        // Regular expression pattern with grouping
        String regex = "(\\d+)-(\\d+)-(\\d+)";  // Match dates in the format YYYY-MM-DD

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regex);

        // Sample text to be matched
        String text = "2023-05-15";

        // Create a matcher object
        Matcher matcher = pattern.matcher(text);

        // Find and extract groups
        if (matcher.find()) {
            System.out.println("Year: " + matcher.group(1));   // Group 1: Year
            System.out.println("Month: " + matcher.group(2));  // Group 2: Month
            System.out.println("Day: " + matcher.group(3));    // Group 3: Day
        }
    }
}

ব্যাখ্যা:

• এখানে (\\d+)-(\\d+)-(\\d+) প্যাটার্নটি তিনটি গ্রুপ তৈরি করছে:
  • গ্রুপ ১: বছর (YYYY)
  • গ্রুপ ২: মাস (MM)
  • গ্রুপ ৩: দিন (DD)
• matcher.group(1), matcher.group(2), এবং matcher.group(3) দিয়ে প্রতিটি গ্রুপের মান বের করা হয়।

আউটপুট:

Year: 2023
Month: 05
Day: 15

Reflection দিয়ে Regular Expressions ব্যবহার করা

যখন Reflection ব্যবহার করা হয়, তখন আপনি কনস্ট্রাক্টর, মেথড বা ফিল্ডের মাধ্যমে ডাইনামিক কোড পরিচালনা করতে পারেন। যদিও Reflection সাধারণত ক্লাসের সদস্যগুলো অ্যাক্সেস করার জন্য ব্যবহৃত হয়, আপনি Reflection এবং Regular Expressions একত্রে ব্যবহার করে আরও ফ্লেক্সিবল কোড তৈরি করতে পারেন।

এখানে একটি উদাহরণ দেওয়া হল যেখানে Reflection ব্যবহার করে ক্লাসের মধ্যে Regex Matching করা হচ্ছে:

Reflection এবং Regex একত্রে ব্যবহার করা

import java.lang.reflect.*;
import java.util.regex.*;

public class ReflectionRegexExample {
    private String text = "apple orange banana apple";

    public boolean checkPattern(String pattern) {
        Pattern compiledPattern = Pattern.compile(pattern);
        Matcher matcher = compiledPattern.matcher(text);
        return matcher.find();  // Checks if the pattern matches the string
    }

    public static void main(String[] args) {
        try {
            // Reflection to access the checkPattern method
            Class<?> cls = Class.forName("ReflectionRegexExample");
            Method method = cls.getDeclaredMethod("checkPattern", String.class);

            // Create an object of ReflectionRegexExample class
            Object obj = cls.getDeclaredConstructor().newInstance();

            // Invoke the checkPattern method using Reflection
            boolean result = (boolean) method.invoke(obj, "apple");

            // Print the result
            System.out.println("Pattern found: " + result);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ব্যাখ্যা:

• এখানে checkPattern মেথডটি একটি regex pattern গ্রহণ করে এবং এটি স্ট্রিংয়ের সাথে মেলে কিনা তা পরীক্ষা করে।
• Reflection ব্যবহার করে checkPattern মেথডটি ডাইনামিকভাবে কল করা হচ্ছে।

আউটপুট:

Pattern found: true

Alternation এবং Grouping হল Java Regular Expressions এর গুরুত্বপূর্ণ বৈশিষ্ট্য যা টেক্সট প্রক্রিয়ায় ব্যবহার করা হয়। Alternation দিয়ে আপনি একাধিক প্যাটার্নের মধ্যে মেলানোর কাজ করতে পারেন এবং Grouping দিয়ে প্যাটার্নের বিভিন্ন অংশ আলাদা করতে পারেন। Reflection ব্যবহার করে আপনি ডাইনামিকভাবে মেথড ইনভোকেশন বা ক্লাস ম্যানিপুলেশন করতে পারেন এবং এই দুটি ধারণা একত্রিত করে আরও ফ্লেক্সিবল এবং শক্তিশালী কোড তৈরি করতে পারেন।

Alternation (বা OR অপারেটর) রেগুলার এক্সপ্রেশন (Regex) এর একটি গুরুত্বপূর্ণ বৈশিষ্ট্য, যা দুটি বা তার বেশি প্যাটার্নের মধ্যে মিল খুঁজে বের করার জন্য ব্যবহৃত হয়। Alternation বা OR অপারেটর (|) ব্যবহার করে, আপনি দুটি বা একাধিক প্যাটার্নের মধ্যে যেকোনো একটি মেলে এমন স্ট্রিং খুঁজে পেতে পারেন।

Alternation (|) কী?

Alternation (|) একটি লজিক্যাল OR অপারেটর, যা রেগুলার এক্সপ্রেশনে দুটি বা তার বেশি প্যাটার্নের মধ্যে যেকোনো একটি ম্যাচ হওয়ার শর্ত সৃষ্টি করে। এটি মূলত দুটি প্যাটার্নের মধ্যে যেকোনো একটি স্ট্রিং মিলে গেলে সেটি একটি সঠিক ম্যাচ হিসেবে গণ্য করে।

Alternation অপারেটর কাজ করে কিভাবে?

• যখন | ব্যবহার করা হয়, তখন এটি দুটি বা একাধিক বিকল্প প্যাটার্ন তৈরি করে।
• OR অপারেটরটি প্রথম প্যাটার্ন এবং দ্বিতীয় প্যাটার্নের মধ্যে যেকোনো একটি ম্যাচ হলে তা মিলিয়ে দেখবে এবং স্ট্রিংটি সঠিক বলে গণ্য করবে।
• যদি প্রথম প্যাটার্নটি মেলে না, তবে দ্বিতীয় প্যাটার্নটি পরীক্ষা করা হবে, এবং এর মধ্যেও কোনটি মেললে সেটি সঠিক হিসেবে গণ্য হবে।

Alternation উদাহরণ:

1. a|b:
   • এই রেগুলার এক্সপ্রেশনটি এমন স্ট্রিংগুলি ম্যাচ করবে যেখানে a বা b যেকোনো একটি আছে।
   • উদাহরণ:
     • "apple" → match (যেহেতু a আছে)
     • "bat" → match (যেহেতু b আছে)
     • "cat" → no match (যেহেতু neither a nor b is found)
2. (dog|cat):
   • এই রেগুলার এক্সপ্রেশনটি এমন স্ট্রিং ম্যাচ করবে যেখানে "dog" অথবা "cat" আছে।
   • উদাহরণ:
     • "dog" → match ("dog" is found)
     • "cat" → match ("cat" is found)
     • "rabbit" → no match (neither "dog" nor "cat" is found)

Alternation এর একটি উদাহরণ Java তে:

import java.util.regex.*;

public class AlternationExample {
    public static void main(String[] args) {
        String text = "apple banana orange";

        // Create a pattern to match either "apple" or "orange"
        Pattern pattern = Pattern.compile("apple|orange");
        Matcher matcher = pattern.matcher(text);

        // Find and display matches
        while (matcher.find()) {
            System.out.println("Found match: " + matcher.group());
        }
    }
}

ব্যাখ্যা:

• Pattern.compile("apple|orange"): এটি এমন একটি রেগুলার এক্সপ্রেশন তৈরি করে যা apple অথবা orange এর মধ্যে যেকোনো একটি স্ট্রিংকে ম্যাচ করবে।
• matcher.find(): এটি স্ট্রিংয়ের মধ্যে রেগুলার এক্সপ্রেশন মেলানো অংশ খুঁজে বের করবে।
• matcher.group(): এটি ম্যাচ হওয়া স্ট্রিংটি ফেরত দেবে।

আউটপুট:

Found match: apple
Found match: orange

Alternation এর ব্যবহার:

• বিভিন্ন শব্দ বা প্যাটার্ন খোঁজা: যদি আপনি বিভিন্ন শব্দ বা প্যাটার্নের মধ্যে যেকোনো একটি খুঁজতে চান, তখন আপনি | অপারেটর ব্যবহার করতে পারেন।
• প্যাটার্ন কোড সহজ করা: অনেক সময় একাধিক প্যাটার্নের মধ্যে মিল খুঁজতে গেলে কোড জটিল হয়ে যায়। Alternation ব্যবহার করে আপনি প্যাটার্নগুলোকে একত্রিত করে কোডটি আরো পরিষ্কার এবং সোজা করতে পারেন।

Alternation বা | অপারেটর রেগুলার এক্সপ্রেশনে একটি অত্যন্ত গুরুত্বপূর্ণ টুল, যা বিভিন্ন প্যাটার্নের মধ্যে OR অপারেশন ব্যবহার করে মিল খুঁজে বের করার কাজ করে। এটি একাধিক বিকল্প প্যাটার্নের মধ্যে কোনটি স্ট্রিংয়ে মেলে তা খুঁজে পেতে সহায়ক হয়।

Java Reflection প্যাকেজে Grouping এর ধারণাটি মূলত Regular Expressions (Regex) এর সাথে সম্পর্কিত। Parentheses বা ব্র্যাকেট () ব্যবহার করে আপনি grouping তৈরি করতে পারেন, যা প্যাটার্নের একটি অংশকে একত্রিত করে। এটি রেগুলার এক্সপ্রেশন (Regex) এর একটি শক্তিশালী ফিচার, যা স্ট্রিং ম্যানিপুলেশনে ব্যবহার করা হয়।

Grouping in Regular Expressions:

() (Parentheses) ব্যবহার করে আপনি রেগুলার এক্সপ্রেশনে একটি গ্রুপ তৈরি করতে পারেন। এই গ্রুপিংয়ের মাধ্যমে আপনি একটি নির্দিষ্ট অংশের মধ্যে যে কোনো প্যাটার্ন মিলালে তার উপর কাজ করতে পারবেন এবং সেই অংশের মান বা ম্যাচগুলো আলাদাভাবে সংগ্রহ করতে পারবেন।

Grouping এর সুবিধা:

• এটি স্ট্রিংয়ের অংশবিশেষ মিলানোর জন্য ব্যবহৃত হয়।
• গ্রুপের সাহায্যে আপনি একাধিক অংশের জন্য মিল পাওয়া ফলাফল পেতে পারেন।
• রেফারেন্স পেতে সাহায্য করে, যেমন স্ট্রিংয়ের মিল পাওয়া অংশ আলাদাভাবে বের করা।

Grouping উদাহরণ:

ধরা যাক, আমরা একটি প্যাটার্নে কিছু শব্দ গ্রুপ করতে চাই এবং পরবর্তীতে তাদের আলাদা আলাদা করে বের করতে চাই।

Parentheses ব্যবহার করে Group তৈরি করা:

import java.util.regex.*;

public class GroupingExample {
    public static void main(String[] args) {
        String text = "My phone number is 123-456-7890 and my address is 123 Main St.";

        // Regular Expression with Grouping (using parentheses)
        Pattern pattern = Pattern.compile("(\\d{3})-(\\d{3})-(\\d{4})");
        Matcher matcher = pattern.matcher(text);

        // Searching for matches
        if (matcher.find()) {
            // Group 1: Area code, Group 2: Middle part, Group 3: Last part of the phone number
            System.out.println("Full phone number: " + matcher.group(0));  // Entire match
            System.out.println("Area code: " + matcher.group(1));  // First group
            System.out.println("Middle part: " + matcher.group(2));  // Second group
            System.out.println("Last part: " + matcher.group(3));  // Third group
        }
    }
}

ব্যাখ্যা:

1. (\\d{3})-(\\d{3})-(\\d{4}): এখানে তিনটি গ্রুপ তৈরি করা হয়েছে, যা স্ট্রিংয়ে তিনটি সংখ্যার অংশকে আলাদা করে মিলাবে।
   • \\d{3}: ৩টি ডিজিট, যা ফোন নাম্বারের প্রথম অংশ (এলাকা কোড) হিসেবে গ্রুপ ১ (Group 1) হবে।
   • \\d{3}: পরবর্তী ৩টি ডিজিট, যা ফোন নাম্বারের মধ্যবর্তী অংশ হবে (Group 2)।
   • \\d{4}: পরবর্তী ৪টি ডিজিট, যা ফোন নাম্বারের শেষ অংশ হবে (Group 3)।
2. matcher.group(0): এটি পুরো মিল হওয়া প্যাটার্নকে ফেরত দেয়, অর্থাৎ পুরো ফোন নাম্বার।
3. matcher.group(1), matcher.group(2), matcher.group(3): এগুলি বিভিন্ন গ্রুপের আলাদা আলাদা অংশকে ফেরত দেয়, যেমন প্রথম ৩ ডিজিট (এলাকা কোড), মধ্যবর্তী ৩ ডিজিট, এবং শেষ ৪ ডিজিট।

আউটপুট:

Full phone number: 123-456-7890
Area code: 123
Middle part: 456
Last part: 7890

Group Numbering:

• group(0) হল পুরো মিল (entire match)।
• group(1), group(2), group(3) ইত্যাদি হল গ্রুপিংয়ের অংশবিশেষ, যা আপনি আলাদাভাবে এক্সেস করতে পারেন।

Named Groups (Java 7 and later):

Java 7 থেকে, আপনি গ্রুপের জন্য নামও দিতে পারেন, যা গ্রুপের নাম দিয়ে তাকে রেফারেন্স করতে সাহায্য করে। এটি (?<name>...) সিনট্যাক্সে করা হয়।

Named Group Example:

import java.util.regex.*;

public class NamedGroupExample {
    public static void main(String[] args) {
        String text = "My phone number is 123-456-7890.";

        // Regular Expression with Named Grouping
        Pattern pattern = Pattern.compile("(?<areaCode>\\d{3})-(?<middlePart>\\d{3})-(?<lastPart>\\d{4})");
        Matcher matcher = pattern.matcher(text);

        // Searching for matches
        if (matcher.find()) {
            // Accessing named groups
            System.out.println("Full phone number: " + matcher.group(0));  // Entire match
            System.out.println("Area code: " + matcher.group("areaCode"));  // Named group "areaCode"
            System.out.println("Middle part: " + matcher.group("middlePart"));  // Named group "middlePart"
            System.out.println("Last part: " + matcher.group("lastPart"));  // Named group "lastPart"
        }
    }
}

ব্যাখ্যা:

1. (?<areaCode>\\d{3}): areaCode নামের একটি গ্রুপ তৈরি করেছে, যা ৩ ডিজিটের সংখ্যা মিলাবে।
2. matcher.group("areaCode"): গ্রুপের নাম দিয়ে আমরা সে গ্রুপের মান পেতে পারি।

আউটপুট:

Full phone number: 123-456-7890
Area code: 123
Middle part: 456
Last part: 7890

• Grouping একটি রেগুলার এক্সপ্রেশন ফিচার যা স্ট্রিংয়ের অংশবিশেষ মিলিয়ে আলাদা করার জন্য ব্যবহৃত হয়।
• Parentheses ব্যবহার করে আপনি প্যাটার্নে গ্রুপ তৈরি করতে পারেন এবং সেই গ্রুপের মান আলাদাভাবে অ্যাক্সেস করতে পারেন।
• Named Groups Java 7 থেকে সমর্থিত, যেখানে আপনি গ্রুপের জন্য নামও দিতে পারেন, যা কোডকে আরও পরিষ্কার এবং সহজবোধ্য করে তোলে।

Java Reflection Package এবং Regular Expressions (Regex) এর মধ্যে একটি গুরুত্বপূর্ণ পার্থক্য রয়েছে। Reflection প্যাকেজ মূলত ক্লাস, মেথড, ফিল্ড, কনস্ট্রাক্টর ইত্যাদি সম্পর্কে তথ্য সংগ্রহ এবং ম্যানিপুলেশন করতে ব্যবহৃত হয়, যখন Regular Expressions মূলত স্ট্রিং ম্যাচিং এবং ম্যানিপুলেশন করতে ব্যবহৃত হয়।

এখানে আমরা Capturing Groups এবং Non-Capturing Groups সম্পর্কে আলোচনা করবো, যা Regular Expressions (Regex) এর গুরুত্বপূর্ণ অংশ। এটি স্ট্রিং এর মধ্যে প্যাটার্ন ম্যাচিং এর সময় কিছু অংশকে আলাদা করে ধরতে সহায়তা করে।

Capturing Groups এবং Non-Capturing Groups এর ধারণা

1. Capturing Groups:

Capturing groups হল রেগুলার এক্সপ্রেশন এর এমন অংশ যা প্যাটার্ন ম্যাচিং করার সময় কিছু নির্দিষ্ট অংশকে আলাদা করে ধরে রাখে। প্রতিটি capturing group একটি সংখ্যার মাধ্যমে চিহ্নিত হয়, যেমন প্রথম গ্রুপ 1, দ্বিতীয় গ্রুপ 2, ইত্যাদি।

• Syntax: (pattern)
  • যেখানে pattern হল রেগুলার এক্সপ্রেশন এর প্যাটার্ন যা আপনি গ্রুপে রাখতে চান।

উদাহরণ: Capturing Group:

ধরা যাক, আমাদের একটি স্ট্রিং আছে: "John, 123 Main Street, NY" এবং আমরা নাম, ঠিকানা, এবং শহর আলাদা করতে চাই।

import java.util.regex.*;

public class CapturingGroupExample {
    public static void main(String[] args) {
        String input = "John, 123 Main Street, NY";
        
        // Capturing Group: (\\w+), (\\d+ \\w+ \\w+), (\\w+)
        Pattern pattern = Pattern.compile("(\\w+), (\\d+ \\w+ \\w+), (\\w+)");
        Matcher matcher = pattern.matcher(input);

        if (matcher.find()) {
            // Group 1: Name, Group 2: Address, Group 3: City
            System.out.println("Name: " + matcher.group(1));
            System.out.println("Address: " + matcher.group(2));
            System.out.println("City: " + matcher.group(3));
        }
    }
}

আউটপুট:

Name: John
Address: 123 Main Street
City: NY

ব্যাখ্যা:

• "(\\w+), (\\d+ \\w+ \\w+), (\\w+)": এখানে তিনটি capturing group রয়েছে:
  • প্রথম গ্রুপ Name-এর জন্য (যেমন John)।
  • দ্বিতীয় গ্রুপ Address-এর জন্য (যেমন 123 Main Street)।
  • তৃতীয় গ্রুপ City-এর জন্য (যেমন NY)।

2. Non-Capturing Groups:

Non-Capturing Groups একই রকম প্যাটার্ন মেলানোর কাজ করে, তবে এগুলো কোনও তথ্য ধরেনি, অর্থাৎ এই গ্রুপগুলোর সাথে কোনো ম্যাচ ধরার প্রয়োজন নেই। এগুলো শুধুমাত্র প্যাটার্নের গ্রুপিং (গোষ্ঠীভুক্ত করা) করতে ব্যবহৃত হয়।

• Syntax: (?:pattern)
  • এখানে pattern হল রেগুলার এক্সপ্রেশন প্যাটার্ন যা আপনি গ্রুপে রাখতে চান, কিন্তু এটি ম্যাচের অংশ হিসেবে সংরক্ষণ করবে না।

উদাহরণ: Non-Capturing Group:

ধরা যাক, আপনি একটি স্ট্রিংতে শহর এবং স্টেটের নাম আলাদা করতে চান, কিন্তু আপনার শহর এবং স্টেটের নামের মধ্যে কোনো পার্থক্য ধরতে হবে না।

import java.util.regex.*;

public class NonCapturingGroupExample {
    public static void main(String[] args) {
        String input = "123 Main Street, New York, NY";
        
        // Non-Capturing Group: (?:\\d+ \\w+ \\w+), (\\w+), (\\w+)
        Pattern pattern = Pattern.compile("(?:\\d+ \\w+ \\w+), (\\w+), (\\w+)");
        Matcher matcher = pattern.matcher(input);

        if (matcher.find()) {
            // Group 1: City, Group 2: State
            System.out.println("City: " + matcher.group(1));
            System.out.println("State: " + matcher.group(2));
        }
    }
}

আউটপুট:

City: New
State: York

ব্যাখ্যা:

• "(?:\\d+ \\w+ \\w+), (\\w+), (\\w+)": এখানে (?:...) হচ্ছে non-capturing group যা শুধুমাত্র গ্রুপিং করার জন্য ব্যবহৃত হয়েছে, কিন্তু সেই অংশটি ধরে রাখছে না।
• City এবং State গ্রুপগুলি শুধুমাত্র ম্যাচ হতে এবং রিটার্ন হতে পারে, কিন্তু প্রথম গ্রুপটি শুধুমাত্র গোষ্ঠীভুক্ত করেছিল।

3. Capturing এবং Non-Capturing Groups এর পার্থক্য:

• Capturing Group: এটি স্ট্রিংয়ের অংশগুলিকে ধরে রাখে, যার মাধ্যমে আপনি এক্সপ্রেশনটি মেলানোর পর ওই অংশগুলি আলাদাভাবে অ্যাক্সেস করতে পারেন। এই গ্রুপের জন্য group() মেথড ব্যবহার করে আপনি মেলানো অংশগুলি বের করতে পারেন।
• Non-Capturing Group: এটি কেবলমাত্র গ্রুপিংয়ের জন্য ব্যবহৃত হয় এবং এটি কোনো তথ্য সংরক্ষণ করে না। যদি আপনি শুধুমাত্র একটি প্যাটার্ন গ্রুপ করতে চান, কিন্তু সেটি প্রয়োজন না হয়, তবে এটি ব্যবহার করা হয়।

Summary of Syntax:

• Capturing Groups এবং Non-Capturing Groups রেগুলার এক্সপ্রেশনগুলোকে আরও শক্তিশালী এবং নমনীয় করে তোলে। Capturing Groups প্যাটার্নের মেলানো অংশগুলোকে আলাদা করে ধরতে ব্যবহৃত হয়, যেখানে Non-Capturing Groups শুধুমাত্র গ্রুপিংয়ের জন্য ব্যবহৃত হয়, কিন্তু কোনো তথ্য সংরক্ষণ করে না।
• এই দুটি কৌশলই স্ট্রিংয়ের মধ্যে প্যাটার্ন খুঁজে বের করার সময় বেশি নমনীয়তা এবং সুবিধা প্রদান করে।

Complex pattern matching প্রায়ই জটিল টেক্সট অথবা স্ট্রিং অনুসন্ধান এবং বিশ্লেষণ করতে ব্যবহৃত হয়, যেমন email validation, phone number formatting, custom log analysis, বা text parsing। এই ধরনের কাজের জন্য Java Regular Expressions (Regex) ব্যবহৃত হয়, যা java.util.regex প্যাকেজে অন্তর্ভুক্ত থাকে।

এখানে, আমরা Java Reflection API এবং Regex এর সাথে Complex Pattern Matching করার একটি প্রাকটিক্যাল উদাহরণ দেখব।

উদাহরণ: Complex Pattern Matching Using Java Reflection

ধরা যাক, আমাদের একটি Employee ক্লাস আছে, যার মধ্যে কিছু ফিল্ড যেমন id, name, email, phone ইত্যাদি রয়েছে। আমরা Reflection API ব্যবহার করে এই ফিল্ডগুলো অ্যাক্সেস করব এবং Regex ব্যবহার করে এই ফিল্ডগুলির মান যাচাই (validate) করব। উদাহরণস্বরূপ, আমরা email validation এবং phone number formatting চেক করব।

Step 1: Employee ক্লাস তৈরি করা

import java.lang.reflect.*;
import java.util.regex.*;

class Employee {
    private int id;
    private String name;
    private String email;
    private String phone;

    public Employee(int id, String name, String email, String phone) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.phone = phone;
    }

    // Getters and setters
    public int getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }
    public String getPhone() { return phone; }
}

Step 2: Regex প্যাটার্ন তৈরি এবং Employee ফিল্ড validate করা

এখন আমরা Employee ক্লাসের ফিল্ডগুলো অ্যাক্সেস করার জন্য Reflection ব্যবহার করব এবং তাদের মান যাচাই করতে Regex প্যাটার্ন ব্যবহার করব।

• Email Validation Regex: সাধারণভাবে email প্যাটার্ন এমনভাবে হবে: ^[a-zA-Z0-9_+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$
• Phone Number Validation Regex: ফোন নম্বরের জন্য একটি সাধারণ প্যাটার্ন হবে: ^\+?[0-9]{1,4}?[-.\s]?[0-9]+[-.\s]?[0-9]+[-.\s]?[0-9]+$

Step 3: Reflection API এবং Regex এর সাথে Validation

import java.lang.reflect.*;
import java.util.regex.*;

public class ReflectionExample {
    public static void main(String[] args) {
        // Employee object creation
        Employee emp = new Employee(101, "John Doe", "johndoe@example.com", "+1-234-567-8901");

        try {
            // Get class object using reflection
            Class<?> clazz = emp.getClass();

            // Validate email using reflection and regex
            Field emailField = clazz.getDeclaredField("email");
            emailField.setAccessible(true);
            String emailValue = (String) emailField.get(emp);
            if (isValidEmail(emailValue)) {
                System.out.println("Valid email: " + emailValue);
            } else {
                System.out.println("Invalid email: " + emailValue);
            }

            // Validate phone number using reflection and regex
            Field phoneField = clazz.getDeclaredField("phone");
            phoneField.setAccessible(true);
            String phoneValue = (String) phoneField.get(emp);
            if (isValidPhone(phoneValue)) {
                System.out.println("Valid phone number: " + phoneValue);
            } else {
                System.out.println("Invalid phone number: " + phoneValue);
            }

        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    // Email validation using regex
    private static boolean isValidEmail(String email) {
        String emailRegex = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
        Pattern pattern = Pattern.compile(emailRegex);
        Matcher matcher = pattern.matcher(email);
        return matcher.matches();
    }

    // Phone number validation using regex
    private static boolean isValidPhone(String phone) {
        String phoneRegex = "^\\+?[0-9]{1,4}?[-.\\s]?[0-9]+[-.\\s]?[0-9]+[-.\\s]?[0-9]+$";
        Pattern pattern = Pattern.compile(phoneRegex);
        Matcher matcher = pattern.matcher(phone);
        return matcher.matches();
    }
}

ব্যাখ্যা:

1. Reflection API:
   • আমরা clazz.getDeclaredField("email") এবং clazz.getDeclaredField("phone") ব্যবহার করে email এবং phone ফিল্ডগুলো অ্যাক্সেস করেছি।
   • setAccessible(true) মেথড ব্যবহার করে private ফিল্ডগুলো অ্যাক্সেস করতে সক্ষম হয়েছি।
2. Regex Validation:
   • isValidEmail এবং isValidPhone মেথডগুলিতে আমরা Regex pattern ব্যবহার করেছি, যা যথাক্রমে email এবং phone number যাচাই করে।
3. Pattern Matching:
   • Pattern.compile() মেথডটি regex প্যাটার্ন কম্পাইল করে এবং matcher.matches() মেথডটি regex এর সাথে স্ট্রিং মিলিয়ে তা যাচাই করে।

Step 4: Output

Valid email: johndoe@example.com
Valid phone number: +1-234-567-8901

অতিরিক্ত বৈশিষ্ট্য এবং প্রয়োগ:

1. Complex Text Parsing:
   • এইভাবে আপনি আরো জটিল প্যাটার্ন ম্যানিপুলেশন করতে পারেন, যেমন custom logs, structured data parsing, বা web scraping।
2. Dynamic Behavior:
   • Reflection API আপনাকে কোডের মধ্যে dynamic behavior তৈরি করতে সাহায্য করে, যেখানে আপনি runtime-এ ফিল্ড এবং মেথডের অ্যাক্সেস পাবেন এবং regex ব্যবহার করে টেক্সট ম্যানিপুলেট করতে পারবেন।
3. Data Validation:
   • Regex এবং Reflection একসাথে ব্যবহার করে আপনি ডেটা ভ্যালিডেশন, যেমন form validation, user input validation, ইত্যাদিতে ব্যবহার করতে পারেন।

Java Reflection এবং Regular Expressions (Regex) একসাথে ব্যবহার করলে আপনি ডাইনামিকভাবে কোডের বিভিন্ন অংশের উপর প্যাটার্ন মেলানো এবং যাচাই করতে পারবেন। Reflection আপনাকে runtime-এ মেথড এবং ফিল্ডগুলোর অ্যাক্সেস দিতে সাহায্য করে, এবং Regex আপনাকে শক্তিশালী এবং জটিল টেক্সট ম্যানিপুলেশন করতে সাহায্য করে। এই দুটি বৈশিষ্ট্য একত্রে ব্যবহার করে আপনি আরও ফ্লেক্সিবল এবং শক্তিশালী ডেটা ভ্যালিডেশন, লোগ অ্যানালাইসিস, এবং ডাইনামিক প্রসেসিং কোড তৈরি করতে পারেন।