java - আমি কীভাবে দুটি স্ট্রিংকে এমনভাবে প্রতিস্থাপন করতে পারি যাতে একজনের অপরটির পরিবর্তে শেষ না হয়?




string replace (17)

ধরা যাক যে আমার কাছে নিম্নলিখিত কোড রয়েছে:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar."
story = story.replace("foo", word1);
story = story.replace("bar", word2);

এই কোডটি চলার পরে, story মান হবে "Once upon a time, there was a foo and a foo."

যদি আমি তাদের বিপরীত ক্রমে প্রতিস্থাপন করি তবে অনুরূপ সমস্যা দেখা দেয়:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar."
story = story.replace("bar", word2);
story = story.replace("foo", word1);

story মান হবে "Once upon a time, there was a bar and a bar."

আমার লক্ষ্য story "Once upon a time, there was a bar and a foo." তে পরিণত করা "Once upon a time, there was a bar and a foo." আমি কীভাবে এটি সম্পাদন করতে পারি?


একমাত্র ঘটনা অদলবদল

ইনপুটটিতে সোয়াপ্যাবল স্ট্রিংগুলির প্রতিটিের মধ্যে কেবল একটির উপস্থিতি থাকলে আপনি নিম্নলিখিতটি করতে পারেন:

যে কোনও প্রতিস্থাপনের দিকে এগিয়ে যাওয়ার আগে শব্দের উপস্থিতির সূচকগুলি পান। এর পরে আমরা কেবলমাত্র এই সূচিগুলিতে পাওয়া শব্দটি প্রতিস্থাপন করি এবং সমস্ত উপস্থিতি নয়। এই সমাধানটি StringBuilder ব্যবহার StringBuilder এবং String.replace() এর মতো মধ্যবর্তী String তৈরি করে না।

একটি বিষয় লক্ষণীয়: যদি অদলবদলের শব্দের বিভিন্ন দৈর্ঘ্য থাকে তবে প্রথম প্রতিস্থাপনের পরে দ্বিতীয় সূচকটি পরিবর্তিত হতে পারে (যদি 1 ম শব্দটি 2 য় এর আগে ঘটে) ঠিক 2 দৈর্ঘ্যের পার্থক্যের সাথে। সুতরাং দ্বিতীয় সূচকটি সারিবদ্ধ করা এটি নিশ্চিত করবে যে আমরা বিভিন্ন দৈর্ঘ্যের সাথে শব্দ অদলবদল করি।

public static String swap(String src, String s1, String s2) {
    StringBuilder sb = new StringBuilder(src);
    int i1 = src.indexOf(s1);
    int i2 = src.indexOf(s2);

    sb.replace(i1, i1 + s1.length(), s2); // Replace s1 with s2
    // If s1 was before s2, idx2 might have changed after the replace
    if (i1 < i2)
        i2 += s2.length() - s1.length();
    sb.replace(i2, i2 + s2.length(), s1); // Replace s2 with s1

    return sb.toString();
}

ঘটনাগুলির স্বেচ্ছাসেবী সংখ্যা মো

পূর্ববর্তী ক্ষেত্রে অনুসারে আমরা প্রথমে শব্দের সূচীগুলি (উপস্থিতিগুলি) সংগ্রহ করব, তবে এই ক্ষেত্রে এটি প্রতিটি শব্দের জন্য পূর্ণসংখ্যার একটি তালিকা হবে, কেবল একটি int । এর জন্য আমরা নিম্নলিখিত ইউটিলিটি পদ্ধতিটি ব্যবহার করব:

public static List<Integer> occurrences(String src, String s) {
    List<Integer> list = new ArrayList<>();
    for (int idx = 0;;)
        if ((idx = src.indexOf(s, idx)) >= 0) {
            list.add(idx);
            idx += s.length();
        } else
            return list;
}

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

public static String swapAll(String src, String s1, String s2) {
    List<Integer> l1 = occurrences(src, s1), l2 = occurrences(src, s2);

    StringBuilder sb = new StringBuilder(src);

    // Replace occurrences by decreasing index, alternating between s1 and s2
    for (int i1 = l1.size() - 1, i2 = l2.size() - 1; i1 >= 0 || i2 >= 0;) {
        int idx1 = i1 < 0 ? -1 : l1.get(i1);
        int idx2 = i2 < 0 ? -1 : l2.get(i2);
        if (idx1 > idx2) { // Replace s1 with s2
            sb.replace(idx1, idx1 + s1.length(), s2);
            i1--;
        } else { // Replace s2 with s1
            sb.replace(idx2, idx2 + s2.length(), s1);
            i2--;
        }
    }

    return sb.toString();
}

আপনি সর্বদা এটি এমন একটি শব্দ দিয়ে প্রতিস্থাপন করতে পারবেন যে আপনি নিশ্চিত যে স্ট্রিং থেকে অন্য কোথাও উপস্থিত হবে না এবং পরে দ্বিতীয়টি প্রতিস্থাপনটি পরে করুন:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar."
story = story.replace("foo", "StringYouAreSureWillNeverOccur").replace("bar", "word2").replace("StringYouAreSureWillNeverOccur", "word1");

দ্রষ্টব্য যে এটি "StringYouAreSureWillNeverOccur" ঘটলে সঠিকভাবে কাজ করবে না ।


আমি কেবল যা ভাগ করতে পারি তা হ'ল আমার নিজস্ব পদ্ধতি।

আপনি একটি অস্থায়ী ব্যবহার করতে পারেন String temp = "<?>"; বা String.Format();

এটি আমার উদাহরণ কোডটি c# - "আইডিয়া কেবল, সঠিক উত্তর নয়" এর মাধ্যমে কনসোল অ্যাপ্লিকেশনে তৈরি হয়েছে ।

static void Main(string[] args)
    {
        String[] word1 = {"foo", "Once"};
        String[] word2 = {"bar", "time"};
        String story = "Once upon a time, there was a foo and a bar.";

        story = Switcher(story,word1,word2);
        Console.WriteLine(story);
        Console.Read();
    }
    // Using a temporary string.
    static string Switcher(string text, string[] target, string[] value)
    {
        string temp = "<?>";
        if (target.Length == value.Length)
        {
            for (int i = 0; i < target.Length; i++)
            {
                text = text.Replace(target[i], temp);
                text = text.Replace(value[i], target[i]);
                text = text.Replace(temp, value[i]);
            }
        }
        return text;
    }

অথবা আপনি এটি ব্যবহার করতে পারেন String.Format();

static string Switcher(string text, string[] target, string[] value)
        {
            if (target.Length == value.Length)
            {
                for (int i = 0; i < target.Length; i++)
                {
                    text = text.Replace(target[i], "{0}").Replace(value[i], "{1}");
                    text = String.Format(text, value[i], target[i]);
                }
            }
            return text;
        }

আউটপুট: time upon a Once, there was a bar and a foo.


এখানে আমার সংস্করণটি যা শব্দ-ভিত্তিক:

class TextReplace
{

    public static void replaceAll (String text, String [] lookup,
                                   String [] replacement, String delimiter)
    {

        String [] words = text.split(delimiter);

        for (int i = 0; i < words.length; i++)
        {

            int j = find(lookup, words[i]);

            if (j >= 0) words[i] = replacement[j];

        }

        text = StringUtils.join(words, delimiter);

    }

    public static  int find (String [] array, String key)
    {

        for (int i = 0; i < array.length; i++)
            if (array[i].equals(key))
                return i;

        return (-1);

    }

}

আপনি ইনপুটটিতে একাধিক অনুসন্ধান-প্রতিস্থাপন অপারেশন করছেন are প্রতিস্থাপনের স্ট্রিংগুলিতে অনুসন্ধানের স্ট্রিং থাকাকালীন এটি অনাকাঙ্ক্ষিত ফলাফল আনবে। Foo-> বার, বার-ফু উদাহরণ বিবেচনা করুন, এখানে প্রতিটি পুনরাবৃত্তির ফলাফল রয়েছে:

  1. একসময়, এখানে একটি ফু ও বার ছিল। (ইনপুট)
  2. এক সময় ছিল, একটি বার এবং একটি বার ছিল। (Foo-> বার)
  3. এক সময়, একটি foo এবং একটি ফু ছিল। (বার-> ফু, আউটপুট)

আপনাকে ফিরে না গিয়ে এক পুনরাবৃত্তিতে প্রতিস্থাপনটি সম্পাদন করতে হবে। একটি নিষ্ঠুর-শক্তি সমাধান নীচে রয়েছে:

  1. কোনও মিল পাওয়া না পাওয়া পর্যন্ত একাধিক অনুসন্ধান স্ট্রিংয়ের জন্য বর্তমান অবস্থান থেকে শেষ পর্যন্ত ইনপুটটি অনুসন্ধান করুন
  2. মিলে যাওয়া অনুসন্ধান স্ট্রিংটি সম্পর্কিত প্রতিস্থাপন স্ট্রিংয়ের সাথে প্রতিস্থাপন করুন
  3. প্রতিস্থাপিত স্ট্রিংয়ের পরে পরবর্তী অক্ষরে বর্তমান অবস্থান সেট করুন
  4. পুনরাবৃত্তি

String.indexOfAny(String[]) -> int[]{index, whichString} মতো একটি ফাংশন কার্যকর হবে। এখানে একটি উদাহরণ (সবচেয়ে দক্ষ একটি নয়):

private static String replaceEach(String str, String[] searchWords, String[] replaceWords) {
    String ret = "";
    while (str.length() > 0) {
        int i;
        for (i = 0; i < searchWords.length; i++) {
            String search = searchWords[i];
            String replace = replaceWords[i];
            if (str.startsWith(search)) {
                ret += replace;
                str = str.substring(search.length());
                break;
            }
        }
        if (i == searchWords.length) {
            ret += str.substring(0, 1);
            str = str.substring(1);
        }
    }
    return ret;
}

কিছু পরীক্ষা:

System.out.println(replaceEach(
    "Once upon a time, there was a foo and a bar.",
    new String[]{"foo", "bar"},
    new String[]{"bar", "foo"}
));
// Once upon a time, there was a bar and a foo.

System.out.println(replaceEach(
    "a p",
    new String[]{"a", "p"},
    new String[]{"apple", "pear"}
));
// apple pear

System.out.println(replaceEach(
    "ABCDE",
    new String[]{"A", "B", "C", "D", "E"},
    new String[]{"B", "C", "E", "E", "F"}
));
// BCEEF

System.out.println(replaceEach(
    "ABCDEF",
    new String[]{"ABCDEF", "ABC", "DEF"},
    new String[]{"XXXXXX", "YYY", "ZZZ"}
));
// XXXXXX
// note the order of search strings, longer strings should be placed first 
// in order to make the replacement greedy

আইডিয়োনে ডেমো আইডিয়োন, বিকল্প কোডে
ডেমো


আপনি একটি মধ্যবর্তী মান ব্যবহার করুন (যা এখনও বাক্যে উপস্থিত নেই)।

story = story.replace("foo", "lala");
story = story.replace("bar", "foo");
story = story.replace("lala", "bar");

সমালোচনার প্রতিক্রিয়া হিসাবে: আপনি যদি zq515sqdqs5d5sq1dqs4d1q5dqqé "& d5d4sqjshsjddhhffsscc, nv^q ^ µù; d & d sdq: d:;) এর মতো একটি বৃহত পর্যায়ে অস্বাভাবিক স্ট্রিং ব্যবহার করেন তবে এটি বিতর্কও বোধ করবে না এবং এটি বিতর্কও নয় যে কোনও ব্যবহারকারী এটিতে প্রবেশ করতে পারে। কেবলমাত্র সোর্স কোডটি জেনে কোনও ব্যবহারকারী হবেন কিনা তা জানার একমাত্র উপায় এবং সেই সময়ে আপনি উদ্বেগের সম্পূর্ণ অন্য স্তরের সাথে রয়েছেন।

হ্যাঁ, সম্ভবত অভিনব রেজেক্স উপায় রয়েছে। আমি এমন কিছু পাঠযোগ্য পছন্দ করি যা আমি জানি যা আমার উপরও ছড়িয়ে পড়বে না।

মন্তব্যগুলিতে @ ডেভিড কনরাড দ্বারা প্রদত্ত দুর্দান্ত পরামর্শটিও পুনর্বার :

অসম্পূর্ণ হওয়ার জন্য বেছে নেওয়া কিছু স্ট্রিং চালাকভাবে (বোকামি) ব্যবহার করবেন না। ইউনিকোড বেসরকারী ব্যবহারের অঞ্চল, U + E000..U + F8FF থেকে অক্ষর ব্যবহার করুন। প্রথমে এ জাতীয় কোনও অক্ষর মুছে ফেলুন, যেহেতু বৈধভাবে ইনপুটটিতে তাদের থাকা উচিত নয় (তাদের কিছু প্রয়োগের মধ্যে অ্যাপ্লিকেশন-নির্দিষ্ট অর্থ রয়েছে), তারপরে প্রতিস্থাপনের সময় এগুলি স্থানধারক হিসাবে ব্যবহার করুন।


আপনি যদি কোনও নির্ভরতা না চান তবে আপনি কেবল এমন অ্যারে ব্যবহার করতে পারেন যা কেবলমাত্র এক-সময়ের পরিবর্তনের অনুমতি দেয়। এটি সবচেয়ে কার্যকর সমাধান নয়, তবে এটি কাজ করা উচিত।

public String replace(String sentence, String[]... replace){
    String[] words = sentence.split("\\s+");
    int[] lock = new int[words.length];
    StringBuilder out = new StringBuilder();

    for (int i = 0; i < words.length; i++) {
        for(String[] r : replace){
            if(words[i].contains(r[0]) && lock[i] == 0){
                words[i] = words[i].replace(r[0], r[1]);
                lock[i] = 1;
            }
        }

        out.append((i < (words.length - 1) ? words[i] + " " : words[i]));
    }

    return out.toString();
}

তারপরে, এটি পুরোপুরি কাজ করে।

String story = "Once upon a time, there was a foo and a bar.";

String[] a = {"foo", "bar"};
String[] b = {"bar", "foo"};
String[] c = {"there", "Pocahontas"};
story = replace(story, a, b, c);

System.out.println(story); // Once upon a time, Pocahontas was a bar and a foo.

আপনি যদি প্রতিস্থাপনের জন্য অনুসন্ধান স্ট্রিংগুলির একাধিক ঘটনা পরিচালনা করতে সক্ষম হতে চান তবে প্রতিটি সন্ধানের শব্দটিতে স্ট্রিংকে বিভক্ত করে সহজেই তা প্রতিস্থাপন করে আপনি এটি করতে পারেন। এখানে একটি উদাহরণ:

String regex = word1 + "|" + word2;
String[] values = Pattern.compile(regex).split(story);

String result;
foreach subStr in values
{
   subStr = subStr.replace(word1, word2);
   subStr = subStr.replace(word2, word1);
   result += subStr;
}

এখানে একটি জাভা 8 স্ট্রিম সম্ভাবনা রয়েছে যা কারও জন্য আকর্ষণীয় হতে পারে:

String word1 = "bar";
String word2 = "foo";

String story = "Once upon a time, there was a foo and a bar.";

// Map is from untranslated word to translated word
Map<String, String> wordMap = new HashMap<>();
wordMap.put(word1, word2);
wordMap.put(word2, word1);

// Split on word boundaries so we retain whitespace.
String translated = Arrays.stream(story.split("\\b"))
    .map(w -> wordMap.getOrDefault(w,  w))
    .collect(Collectors.joining());

System.out.println(translated);

এখানে জাভা in-তে একই অ্যালগরিদমের একটি আনুমানিক চিত্র রয়েছে:

String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar.";

// Map is from untranslated word to translated word
Map<String, String> wordMap = new HashMap<>();
wordMap.put(word1, word2);
wordMap.put(word2, word1);

// Split on word boundaries so we retain whitespace.
StringBuilder translated = new StringBuilder();
for (String w : story.split("\\b"))
{
  String tw = wordMap.get(w);
  translated.append(tw != null ? tw : w);
}

System.out.println(translated);

এটি কাজ করে এবং সহজ:

public String replaceBoth(String text, String token1, String token2) {            
    return text.replace(token1, "\ufdd0").replace(token2, token1).replace("\ufdd0", token2);
    }

আপনি এটি এর মতো ব্যবহার করুন:

replaceBoth("Once upon a time, there was a foo and a bar.", "foo", "bar");

দ্রষ্টব্য: এই স্ট্রিংগুলিতে character \ufdd0 অক্ষর না থাকা স্ট্রিংগুলিতে গণনা করা হয়, যা ইউনিকোড দ্বারা অভ্যন্তরীণ ব্যবহারের জন্য স্থায়ীভাবে সংরক্ষিত একটি চরিত্র ( http://www.unicode.org/faq/private_use.html দেখুন):

আমি এটি প্রয়োজনীয় বলে মনে করি না, তবে আপনি যদি পুরোপুরি নিরাপদ থাকতে চান তবে আপনি এটি ব্যবহার করতে পারেন:

public String replaceBoth(String text, String token1, String token2) {
    if (text.contains("\ufdd0") || token1.contains("\ufdd0") || token2.contains("\ufdd0")) throw new IllegalArgumentException("Invalid character.");
    return text.replace(token1, "\ufdd0").replace(token2, token1).replace("\ufdd0", token2);
    }

জাভা 8-এ ওয়ান-লাইনার:

    story = Pattern
        .compile(String.format("(?<=%1$s)|(?=%1$s)", "foo|bar"))
        .splitAsStream(story)
        .map(w -> ImmutableMap.of("bar", "foo", "foo", "bar").getOrDefault(w, w))
        .collect(Collectors.joining());
  • তাত্পর্যপূর্ণ নিয়মিত এক্সপ্রেশন ( ?<= ?= ): http://www.regular-expressions.info/lookaround.html
  • শব্দগুলিতে যদি বিশেষ রেজেক্স অক্ষর থাকতে পারে তবে Pattern.quote থেকে বাঁচতে Pattern.quote ব্যবহার করুন।
  • আমি দৃis়তার জন্য পেয়ারা ইমটুটেবল ম্যাপ ব্যবহার করি তবে স্পষ্টতই অন্য কোনও মানচিত্রও কাজটি করবে।

প্রথম শব্দটি প্রতিস্থাপনের জন্য অনুসন্ধান করুন। যদি এটি স্ট্রিংটিতে থাকে তবে সংঘটন হওয়ার আগে স্ট্রিংয়ের অংশে এবং ঘটনার পরে স্ট্রিংয়ের অংশে পুনরাবৃত্তি করুন।

অন্যথায়, প্রতিস্থাপন করার জন্য পরবর্তী শব্দটি দিয়ে চালিয়ে যান।

একটি নিষ্পাপ বাস্তবায়ন এর মতো দেখতে পারে

public static String replaceAll(String input, String[] search, String[] replace) {
  return replaceAll(input, search, replace, 0);
}

private static String replaceAll(String input, String[] search, String[] replace, int i) {
  if (i == search.length) {
    return input;
  }
  int j = input.indexOf(search[i]);
  if (j == -1) {
    return replaceAll(input, search, replace, i + 1);
  }
  return replaceAll(input.substring(0, j), search, replace, i + 1) +
         replace[i] +
         replaceAll(input.substring(j + search[i].length()), search, replace, i);
}

নমুনা ব্যবহার:

String input = "Once upon a baz, there was a foo and a bar.";
String[] search = new String[] { "foo", "bar", "baz" };
String[] replace = new String[] { "bar", "baz", "foo" };
System.out.println(replaceAll(input, search, replace));

আউটপুট:

Once upon a foo, there was a bar and a baz.

একটি স্বল্প সংস্করণী সংস্করণ:

public static String replaceAll(String input, String[] search, String[] replace) {
  StringBuilder sb = new StringBuilder();
  replaceAll(sb, input, 0, input.length(), search, replace, 0);
  return sb.toString();
}

private static void replaceAll(StringBuilder sb, String input, int start, int end, String[] search, String[] replace, int i) {
  while (i < search.length && start < end) {
    int j = indexOf(input, search[i], start, end);
    if (j == -1) {
      i++;
    } else {
      replaceAll(sb, input, start, j, search, replace, i + 1);
      sb.append(replace[i]);
      start = j + search[i].length();
    }
  }
  sb.append(input, start, end);
}

দুর্ভাগ্যক্রমে, জাভার indexOf(String str, int fromIndex, int toIndex) নেই indexOf(String str, int fromIndex, int toIndex) পদ্ধতি নেই। আমি এখানে indexOf বাস্তবায়ন বাদ দিয়েছি কারণ আমি নিশ্চিত যে এটি সঠিক নয়, তবে এটি এখানে পোস্ট করা বিভিন্ন সমাধানের মোটামুটি সময় সহ ideone পাওয়া যাবে।


here পাওয়া উত্তর ব্যবহার করে আপনি যে স্ট্রিং দিয়ে প্রতিস্থাপন করতে চান তার সমস্ত উপস্থিতি খুঁজে পেতে পারেন।

সুতরাং উদাহরণস্বরূপ আপনি উপরের এসও উত্তরে কোডটি চালান। সূচকের দুটি টেবিল তৈরি করুন (আসুন বার এবং foo কেবল আপনার স্ট্রিংয়ের মধ্যে একবারে উপস্থিত হবে না) এবং আপনি সেই টেবিলগুলির সাথে আপনার স্ট্রিংয়ের পরিবর্তে কাজ করতে পারেন।

এখন নির্দিষ্ট সূচক অবস্থানগুলিতে প্রতিস্থাপনের জন্য আপনি ব্যবহার করতে পারেন:

public static String replaceStringAt(String s, int pos, String c) {
   return s.substring(0,pos) + c + s.substring(pos+1);
}

যেখানে pos সূচক যেখানে আপনার স্ট্রিং (INDEX টেবিল আমি উপরের উদ্ধৃত থেকে) শুরু হয়। সুতরাং আসুন আমরা প্রত্যেকটির জন্য সূচির দুটি টেবিল তৈরি করেছি। আসুন তাদের কল করুন indexBar এবং indexFoo

এখন তাদের প্রতিস্থাপনের ক্ষেত্রে আপনি কেবল দুটি লুপ চালাতে পারেন, প্রতিস্থাপনের জন্য আপনার তৈরি করতে চান।

for(int i=0;i<indexBar.Count();i++)
replaceStringAt(originalString,indexBar[i],newString);

একইভাবে অন্য লুপ indexFoo

এটি এখানে অন্যান্য উত্তরের মতো দক্ষ নাও হতে পারে তবে এটি মানচিত্র বা অন্যান্য জিনিসগুলির চেয়ে বোঝা সহজ।

এটি সর্বদা আপনার পছন্দসই ফলাফল এবং প্রতিটি স্ট্রিংয়ের একাধিক সম্ভাব্য সংঘটনগুলির জন্য দেয়। যতক্ষণ না আপনি প্রতিটি ঘটনার সূচক সঞ্চয় করেন।

এছাড়াও এই উত্তরের কোনও পুনরাবৃত্তি বা কোনও বাহ্যিক নির্ভরতা প্রয়োজন। জটিলতা যতটা যায় ততটুকুই এটি O (n স্কোয়ার্ড), অন্যদিকে n উভয় শব্দের সংখ্যার যোগফল।



StringBuilder ব্যবহার বিবেচনা করুন StringBuilder

তারপরে সূচিটি সংরক্ষণ করুন যেখানে প্রতিটি স্ট্রিং শুরু হওয়া উচিত। আপনি যদি প্রতিটি পজিশনে কোনও স্থান ধারক চরিত্র ব্যবহার করেন তবে এটি সরিয়ে ফেলুন এবং ব্যবহারকারীদের স্ট্রিং .োকান। তারপরে আপনি শুরু অবস্থানটিতে স্ট্রিংয়ের দৈর্ঘ্য যোগ করে শেষ অবস্থানটি মানচিত্র করতে পারেন।

String firstString = "???";
String secondString  = "???"

StringBuilder story = new StringBuilder("One upon a time, there was a " 
    + firstString
    + " and a "
    + secondString);

int  firstWord = 30;
int  secondWord = firstWord + firstString.length() + 7;

story.replace(firstWord, firstWord + firstString.length(), userStringOne);
story.replace(secondWord, secondWord + secondString.length(), userStringTwo);

firstString = userStringOne;
secondString = userStringTwo;

return story;

String.regionMatches ব্যবহার করে এটি করার জন্য কোনও পদ্ধতি রচনা করা সহজ:

public static String simultaneousReplace(String subject, String... pairs) {
    if (pairs.length % 2 != 0) throw new IllegalArgumentException(
        "Strings to find and replace are not paired.");
    StringBuilder sb = new StringBuilder();
    outer:
    for (int i = 0; i < subject.length(); i++) {
        for (int j = 0; j < pairs.length; j += 2) {
            String find = pairs[j];
            if (subject.regionMatches(i, find, 0, find.length())) {
                sb.append(pairs[j + 1]);
                i += find.length() - 1;
                continue outer;
            }
        }
        sb.append(subject.charAt(i));
    }
    return sb.toString();
}

পরীক্ষামূলক:

String s = "There are three cats and two dogs.";
s = simultaneousReplace(s,
    "cats", "dogs",
    "dogs", "budgies");
System.out.println(s);

আউটপুট:

তিনটি কুকুর এবং দুটি বুড়ি রয়েছে।

এটি অবিলম্বে সুস্পষ্ট নয়, তবে এর মতো একটি ক্রিয়াটি এখনও প্রতিস্থাপনগুলি নির্দিষ্ট করা ক্রমের উপর নির্ভরশীল হতে পারে। বিবেচনা:

String truth = "Java is to JavaScript";
truth += " as " + simultaneousReplace(truth,
    "JavaScript", "Hamster",
    "Java", "Ham");
System.out.println(truth);

আউটপুট:

জাভা জাভাস্ক্রিপ্ট যেমন হ্যাম হ্যামস্টারের কাছে

তবে প্রতিস্থাপনগুলি বিপরীত করুন:

truth += " as " + simultaneousReplace(truth,
    "Java", "Ham",
    "JavaScript", "Hamster");

আউটপুট:

জাভা জাভাস্ক্রিপ্ট যেমন হ্যাম হ্যামস্ক্রিপ্ট হয়

ওহো! :)

অতএব দীর্ঘতম ম্যাচটি সন্ধান করা নিশ্চিত করা কখনও কখনও দরকারী (যেমন পিএইচপি-র strtr ফাংশন যেমন উদাহরণস্বরূপ)। পদ্ধতির এই সংস্করণটি এটি করবে:

public static String simultaneousReplace(String subject, String... pairs) {
    if (pairs.length % 2 != 0) throw new IllegalArgumentException(
        "Strings to find and replace are not paired.");
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < subject.length(); i++) {
        int longestMatchIndex = -1;
        int longestMatchLength = -1;
        for (int j = 0; j < pairs.length; j += 2) {
            String find = pairs[j];
            if (subject.regionMatches(i, find, 0, find.length())) {
                if (find.length() > longestMatchLength) {
                    longestMatchIndex = j;
                    longestMatchLength = find.length();
                }
            }
        }
        if (longestMatchIndex >= 0) {
            sb.append(pairs[longestMatchIndex + 1]);
            i += longestMatchLength - 1;
        } else {
            sb.append(subject.charAt(i));
        }
    }
    return sb.toString();
}

নোট করুন যে উপরের পদ্ধতিগুলি কেস-সংবেদনশীল। আপনার যদি কেস-সংবেদনশীল সংস্করণ দরকার হয় তবে String.regionMatches সংশোধন করা সহজ কারণ String.regionMatches একটি ignoreCase প্যারামিটার নিতে পারে।


String word1 = "bar";
String word2 = "foo";
String story = "Once upon a time, there was a foo and a bar."

ছোট্ট কৌশলযুক্ত উপায় কিন্তু আপনাকে আরও কিছু চেক করা দরকার।

স্ট্রিংকে অক্ষরের অ্যারেতে রূপান্তর করুন

   String temp[] = story.split(" ");//assume there is only spaces.

টেম্পে 2. লুপ করুন এবং এর foo সাথে bar এবং এর bar সাথে foo প্রতিস্থাপনযোগ্য স্ট্রিং হওয়ার কোনও সম্ভাবনা নেই বলে প্রতিস্থাপন করুন।








replace