আমি জাভা রেজেেক্সে গ্রুপগুলি প্রতিস্থাপন করতে পারি?

Question 1

আমার এই কোডটি রয়েছে এবং আমি জানতে চাই, আমি জাভা রেজেজেলে কেবলমাত্র গোষ্ঠীগুলি (সমস্ত প্যাটার্ন নয়) প্রতিস্থাপন করতে পারি। কোড:

 //...
 Pattern p = Pattern.compile("(\\d).*(\\d)");
    String input = "6 example input 4";
    Matcher m = p.matcher(input);
    if (m.find()) {

        //Now I want replace group one ( (\\d) ) with number 
       //and group two (too (\\d) ) with 1, but I don't know how.

    }

Question 2

$nক্যাপচারিত উপ-অনুচ্ছেদগুলিতে উল্লেখ করতে (যেখানে এন একটি সংখ্যা রয়েছে) ব্যবহার করুন replaceFirst(...)। আমি ধরে নিচ্ছি আপনি প্রথম গ্রুপটির সাথে আক্ষরিক স্ট্রিং "নম্বর" এবং দ্বিতীয় গ্রুপটি প্রথম দলের মান দিয়ে প্রতিস্থাপন করতে চেয়েছিলেন ।

Pattern p = Pattern.compile("(\\d)(.*)(\\d)");
String input = "6 example input 4";
Matcher m = p.matcher(input);
if (m.find()) {
    // replace first number with "number" and second number with the first
    String output = m.replaceFirst("number $3$1");  // number 46
}

(\D+)পরিবর্তে দ্বিতীয় গ্রুপের জন্য বিবেচনা করুন (.*)। *একটি লোভী ম্যাচার, এবং প্রথমে শেষ অঙ্কটি গ্রাস করবে। (\d)চূড়ান্ত অঙ্কের সাথে ম্যাচ করতে পারার আগে ম্যাচারকে বুঝতে হবে যে ফাইনালের সাথে ম্যাচ করার মতো কিছুই নেই।

Question 3

আপনি জেনেরিক প্রতিস্থাপন পদ্ধতিটি ব্যবহার করতে Matcher#start(group)এবং Matcher#end(group)তৈরি করতে পারেন :

public static String replaceGroup(String regex, String source, int groupToReplace, String replacement) {
    return replaceGroup(regex, source, groupToReplace, 1, replacement);
}

public static String replaceGroup(String regex, String source, int groupToReplace, int groupOccurrence, String replacement) {
    Matcher m = Pattern.compile(regex).matcher(source);
    for (int i = 0; i < groupOccurrence; i++)
        if (!m.find()) return source; // pattern not met, may also throw an exception here
    return new StringBuilder(source).replace(m.start(groupToReplace), m.end(groupToReplace), replacement).toString();
}

public static void main(String[] args) {
    // replace with "%" what was matched by group 1 
    // input: aaa123ccc
    // output: %123ccc
    System.out.println(replaceGroup("([a-z]+)([0-9]+)([a-z]+)", "aaa123ccc", 1, "%"));

    // replace with "!!!" what was matched the 4th time by the group 2
    // input: a1b2c3d4e5
    // output: a1b2c3d!!!e5
    System.out.println(replaceGroup("([a-z])(\\d)", "a1b2c3d4e5", 2, 4, "!!!"));
}

এখানে অনলাইন ডেমো পরীক্ষা করুন ।

Question 4

একটি মৃত ঘোড়াটিকে পেটানোর জন্য দুঃখিত, তবে এটি একপ্রকার অদ্ভুত যে কেউই এটিকে নির্দেশ করেনি - "হ্যাঁ আপনি পারেন তবে এটি বাস্তব জীবনে আপনি কীভাবে দলগুলিকে বন্দী করে রাখছেন তার বিপরীত"।

আপনি যদি রেজেক্সকে যেভাবে ব্যবহার করতে চান সেভাবে ব্যবহার করেন, সমাধানটি এর মতোই সহজ:

"6 example input 4".replaceAll("(?:\\d)(.*)(?:\\d)", "number$11");

বা নীচে shmosel দ্বারা যথাযথভাবে নির্দেশিত,

"6 example input 4".replaceAll("\d(.*)\d", "number$11");

... যেহেতু আপনার রেজেক্সে দশমিকগুলি মোটেও গ্রুপ করার কোনও ভাল কারণ নেই।

আপনি যে স্ট্রিংটি ফেলে দিতে চান সেই অংশগুলিতে আপনি সাধারণত ক্যাপচারিং গ্রুপ ব্যবহার করবেন না , আপনি যে স্ট্রিংটি রাখতে চান তার অংশে ব্যবহার করুন ।

আপনি যদি সত্যিই এমন গ্রুপগুলি চান যা আপনি প্রতিস্থাপন করতে চান তবে আপনি সম্ভবত এটির বদলে যা চান সেটি হ'ল টেম্প্লেটিং ইঞ্জিন (যেমন গোঁফ, ইজেস, স্ট্রিংটেম্পলেট, ...)।

কৌতূহলীদের একপাশে, এমনকি রেজেক্সগুলিতে নন-ক্যাপচারিং গোষ্ঠীগুলি ঠিক সেখানে রয়েছে যে রেজেক্স ইঞ্জিনটি ভেরিয়েবল পাঠ্যকে সনাক্ত করতে এবং এড়াতে তাদের প্রয়োজন। উদাহরণস্বরূপ, ইন

(?:abc)*(capture me)(?:bcd)*

আপনি তাদের প্রয়োজন হলে আপনার ইনপুট হয় "abcabc মত সন্ধান করতে পারেন ক্যাপচার আমাকে bcdbcd" বা "এবিসি ক্যাপচার আমাকে BCD" বা এমনকি শুধু "আমাকে ক্যাপচার"।

বা এটিকে অন্য উপায়ে রাখতে: পাঠ্যটি যদি সর্বদা একই থাকে এবং আপনি এটি ক্যাপচার না করেন তবে গোষ্ঠীগুলি ব্যবহার করার কোনও কারণ নেই।

Question 5

চারদিকে পেরেন যোগ করে তৃতীয় গোষ্ঠী যুক্ত করুন .*, তারপরে অনুবর্তনটি এর সাথে প্রতিস্থাপন করুন "number" + m.group(2) + "1"। যেমন:

String output = m.replaceFirst("number" + m.group(2) + "1");

Question 6

গ্রুপ পজিশনগুলি পেতে আপনি ম্যাচার.স্টার্ট () এবং ম্যাচার.এন্ড () পদ্ধতি ব্যবহার করতে পারেন। সুতরাং এই অবস্থানগুলি ব্যবহার করে আপনি যে কোনও পাঠ্য সহজেই প্রতিস্থাপন করতে পারেন।

Question 7

ইনপুট থেকে পাসওয়ার্ড ক্ষেত্রগুলি প্রতিস্থাপন করুন:

{"_csrf":["9d90c85f-ac73-4b15-ad08-ebaa3fa4a005"],"originPassword":["uaas"],"newPassword":["uaas"],"confirmPassword":["uaas"]}



  private static final Pattern PATTERN = Pattern.compile(".*?password.*?\":\\[\"(.*?)\"\\](,\"|}$)", Pattern.CASE_INSENSITIVE);

  private static String replacePassword(String input, String replacement) {
    Matcher m = PATTERN.matcher(input);
    StringBuffer sb = new StringBuffer();
    while (m.find()) {
      Matcher m2 = PATTERN.matcher(m.group(0));
      if (m2.find()) {
        StringBuilder stringBuilder = new StringBuilder(m2.group(0));
        String result = stringBuilder.replace(m2.start(1), m2.end(1), replacement).toString();
        m.appendReplacement(sb, result);
      }
    }
    m.appendTail(sb);
    return sb.toString();
  }

  @Test
  public void test1() {
    String input = "{\"_csrf\":[\"9d90c85f-ac73-4b15-ad08-ebaa3fa4a005\"],\"originPassword\":[\"123\"],\"newPassword\":[\"456\"],\"confirmPassword\":[\"456\"]}";
    String expected = "{\"_csrf\":[\"9d90c85f-ac73-4b15-ad08-ebaa3fa4a005\"],\"originPassword\":[\"**\"],\"newPassword\":[\"**\"],\"confirmPassword\":[\"**\"]}";
    Assert.assertEquals(expected, replacePassword(input, "**"));
  }

Question 8

এখানে একটি পৃথক সমাধান, এটি একাধিক ম্যাচে একক গ্রুপের প্রতিস্থাপনের অনুমতি দেয়। এটি এক্সিকিউশন অর্ডারকে বিপরীত করতে স্ট্যাক ব্যবহার করে, সুতরাং স্ট্রিং অপারেশনটি নিরাপদে সম্পাদন করা যায়।

private static void demo () {

    final String sourceString = "hello world!";

    final String regex = "(hello) (world)(!)";
    final Pattern pattern = Pattern.compile(regex);

    String result = replaceTextOfMatchGroup(sourceString, pattern, 2, world -> world.toUpperCase());
    System.out.println(result);  // output: hello WORLD!
}

public static String replaceTextOfMatchGroup(String sourceString, Pattern pattern, int groupToReplace, Function<String,String> replaceStrategy) {
    Stack<Integer> startPositions = new Stack<>();
    Stack<Integer> endPositions = new Stack<>();
    Matcher matcher = pattern.matcher(sourceString);

    while (matcher.find()) {
        startPositions.push(matcher.start(groupToReplace));
        endPositions.push(matcher.end(groupToReplace));
    }
    StringBuilder sb = new StringBuilder(sourceString);
    while (! startPositions.isEmpty()) {
        int start = startPositions.pop();
        int end = endPositions.pop();
        if (start >= 0 && end >= 0) {
            sb.replace(start, end, replaceStrategy.apply(sourceString.substring(start, end)));
        }
    }
    return sb.toString();       
}