জাভাতে স্ট্রিংটি সমান দৈর্ঘ্যের সাবস্ট্রিংগুলিতে বিভক্ত করুন

Question

"Thequickbrownfoxjumps"জাভাতে সমান আকারের সাবস্ট্রিংগুলিতে স্ট্রিংটি কীভাবে বিভক্ত করা যায় । যেমন। "Thequickbrownfoxjumps"4 সমান আকারের আউটপুট দেওয়া উচিত।

["Theq","uick","brow","nfox","jump","s"]

অনুরূপ প্রশ্ন:

স্কালায় স্ট্রিংটি সমান-দৈর্ঘ্যের সাবস্ট্রিংগুলিতে বিভক্ত করুন

Comments

তুমি কি চেষ্টা করেছ? কেন যে কাজ হয়নি?

— থিলো

এর জন্য আপনার কি একটি রেজেক্স ব্যবহার করা দরকার? কেবল রেজেক্স ট্যাগের কারণে জিজ্ঞাসা করছি ...

— টিম পিটজ্যাকার

@ যে থিলো লিঙ্কটি তিনি পোস্ট করেছেন তা স্কালার জন্য, তিনি জাভাতেও একই বিষয়ে জিজ্ঞাসা করছেন

— জয়দীপ প্যাটেল

@ থিলো: আমি জিজ্ঞাসা করছিলাম কীভাবে এটি জাভাতে করা যায়, যেমন স্কেলার জন্য দেওয়া উত্তরের মতো।

— এমিল

Answer 1

এখানে রেজেক্স ওয়ান-লাইনার সংস্করণটি রয়েছে:

System.out.println(Arrays.toString(
    "Thequickbrownfoxjumps".split("(?<=\\G.{4})")
));

\Gপূর্বের ম্যাচটি যেখানে শেষ হয়েছিল সেই অবস্থানের সাথে শূন্য-প্রস্থের প্রতিবেদন। যদি ছিল কোনো পূর্ববর্তী ম্যাচ, ইনপুট শুরুতে হিসাবে একই সাথে মেলে \A। বদ্ধ চেহারাটি শেষ ম্যাচের শেষের সাথে চারটি অক্ষরের সাথে এমন অবস্থানের সাথে মেলে।

উভয় চেহারা এবং পিছনে \Gউন্নত regex বৈশিষ্ট্য, সমস্ত স্বাদ দ্বারা সমর্থিত নয়। তদ্ব্যতীত, \Gএটি সমর্থন করে যে স্বাদগুলি জুড়ে নিয়মিত প্রয়োগ করা হয় না। এই কৌশলটি জাভা , পার্ল,। নেট এবং জেজিফটগুলিতে কাজ করবে (উদাহরণস্বরূপ) , তবে পিএইচপি (পিসিআরই), রুবি ১.৯+ বা টেক্সটমেট (উভয়ই ওনিগুরুমা) নয়। জাভাস্ক্রিপ্টের /y(স্টিকি ফ্ল্যাগ) এর মতো নমনীয় \Gনয় এবং জেএস লুক ব্যাককে সমর্থন করলেও এইভাবে ব্যবহার করা যায় না।

আমার উল্লেখ করা উচিত যে আপনার কাছে অন্য বিকল্প থাকলে আমি এই সমাধানটি অগত্যা সুপারিশ করি না । অন্যান্য উত্তরের নন-রেজেক্স সমাধানগুলি দীর্ঘ হতে পারে তবে সেগুলি স্ব-ডকুমেন্টিংও রয়েছে; এই ঠিক এর বিপরীত সম্পর্কে । ;)

এছাড়াও, এটি অ্যান্ড্রয়েডে কাজ করে না, যা \Gলুকবিহিন্ডগুলিতে ব্যবহার সমর্থন করে না ।

Comments

পিএইচপি 5.2.4 এ নিম্নলিখিত কোডগুলি কাজ করে: প্রিগ_স্প্লিট ('/ (? <= \ জি। {'। $ লেন। '}) / U', $আরটি, -1, PREG_SPLIT_NO_EMPTY) রিটার্ন করুন;

— ইগোর

রেকর্ডের জন্য, String.substring()একটি রেজেক্সের পরিবর্তে ব্যবহার করা, যখন কয়েকটি অতিরিক্ত লাইন কোডের প্রয়োজন হয়, আরও দ্রুত 5x এর ক্রম দিয়ে কোথাও চলবে ...

— মুর

জাভাতে এটি নতুন লাইনের সাথে স্ট্রিংয়ের জন্য কাজ করে না। এটি কেবলমাত্র প্রথম নতুনলাইন পর্যন্ত চেক করবে এবং যদি সেই নতুনলাইনটি বিভক্ত-আকারের আগে হয় তবে স্ট্রিংটি বিভক্ত হবে না। নাকি আমি কিছু মিস করেছি?

— জোনসন

Multilines উপর বিভাজন টেক্সট দরকার একটি পূর্বে সমাধান: সম্পূর্ণতার অভিপ্রায় জন্য (?s)Regex মধ্যে: (?s)(?<=\\G.{4})।

— বুবল

সংকলন-সময়ে সম্পূর্ণ জাভা বার্ফস:java.util.regex.PatternSyntaxException: Look-behind pattern matches must have a bounded maximum length

— জেফ্রি ব্লাটম্যান

Answer 2

ভাল, সাধারণ গাণিতিক এবং স্ট্রিং ক্রিয়াকলাপগুলির সাথে এটি করা মোটামুটি সহজ:

public static List<String> splitEqually(String text, int size) {
    // Give the list the right capacity to start with. You could use an array
    // instead if you wanted.
    List<String> ret = new ArrayList<String>((text.length() + size - 1) / size);

    for (int start = 0; start < text.length(); start += size) {
        ret.add(text.substring(start, Math.min(text.length(), start + size)));
    }
    return ret;
}

আমি মনে করি না এটির জন্য একটি রেজেেক্স ব্যবহার করা সত্যই মূল্যবান।

সম্পাদনা: একটি রেজেক্স ব্যবহার না করার জন্য আমার যুক্তি:

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

Comments

@ এমিল: আসলে, আপনি একটি রেইগেক্সের জন্য জিজ্ঞাসা করেননি । এটি ট্যাগগুলিতে রয়েছে, তবে প্রশ্নটিতে কোনও কিছুই নিজেই একটি রেজেক্সের জন্য জিজ্ঞাসা করে না। আপনি এই পদ্ধতিটি এক জায়গায় রেখেছেন এবং তারপরে আপনি আপনার কোডের যে কোনও জায়গায় স্ট্রিংটি খুব পঠনযোগ্য স্টেটমেন্টে বিভক্ত করতে পারেন ।

— জন স্কিটি

এমিল এটি কোনও রেজেক্সের জন্য নয়। সময়কাল।

— ক্রিস

@ এমিল: আপনি যদি স্ট্রিং বিভক্ত করার জন্য ওয়ান-লাইনার চান তবে আমি Splitter.fixedLength(4)সিনিয়র দ্বারা প্রস্তাবিত পরামর্শ হিসাবে পেয়ারা সুপারিশ করব।

— কলিনড

@ জায়ে: আসুন আপনার এই ব্যঙ্গাত্মক হওয়া উচিত নয়। আমি নিশ্চিত যে এটি কেবলমাত্র এক লাইনে রেজেক্স ব্যবহার করে করা যেতে পারে A একটি নির্দিষ্ট দৈর্ঘ্যের সাব-স্ট্রিংটিও একটি নিদর্শন W এই উত্তর সম্পর্কে আপনি কী বলেন? stackoverflow.com/questions/3760152/… ।

— এমিল

@ এমিল: আমি অভদ্র হতে চাই না, কেবল তীক্ষ্ণ। আমার বক্তব্যটির গুরুতর অংশটি হ্যাঁ, যখন আমি নিশ্চিত যে আপনি এটি করতে একটি রেইগেক্স নিয়ে আসতে পারেন - আমি দেখছি অ্যালান মুরের একটি দাবি আছে যে তিনি কাজ করেন বলে দাবি করেছেন - এটি গুপ্ত এবং পরবর্তী প্রোগ্রামারের পক্ষে এটি কঠিন বুঝতে এবং বজায় রাখা। একটি স্ট্রাইং সমাধান স্বজ্ঞাত এবং পাঠযোগ্য হতে পারে। জন স্কিটির চতুর্থ বুলেট দেখুন: আমি 100% এর সাথে একমত

— জয়

Answer 3

গুগল পেয়ারার সাথে এটি খুব সহজ :

for(final String token :
    Splitter
        .fixedLength(4)
        .split("Thequickbrownfoxjumps")){
    System.out.println(token);
}

আউটপুট:

Theq
uick
brow
nfox
jump
s

অথবা যদি আপনাকে অ্যারের হিসাবে ফলাফলের প্রয়োজন হয় তবে আপনি এই কোডটি ব্যবহার করতে পারেন:

String[] tokens =
    Iterables.toArray(
        Splitter
            .fixedLength(4)
            .split("Thequickbrownfoxjumps"),
        String.class
    );

রেফারেন্স:

• Splitter.fixedLength()
• Splitter.split()
• Iterables.toArray()

দ্রষ্টব্য: স্প্লিটার নির্মাণ উপরের ইনলাইন দেখানো হয়েছে, তবে স্প্লিট্টারগুলি পরিবর্তনযোগ্য এবং পুনঃব্যবহারযোগ্য হওয়ায় এগুলি ধ্রুবকগুলিতে সংরক্ষণ করা ভাল অভ্যাস:

private static final Splitter FOUR_LETTERS = Splitter.fixedLength(4);

// more code

for(final String token : FOUR_LETTERS.split("Thequickbrownfoxjumps")){
    System.out.println(token);
}

Comments

পোস্টটির জন্য ধন্যবাদ (আমাকে পেয়ারা গ্রন্থাগার পদ্ধতি সম্পর্কে সচেতন করার জন্য)। তবে আমাকে রেইজেক্স উত্তরটি গ্রহণ করতে হবে স্ট্যাকওভারফ্লো / প্রশ্নগুলি / 603760০১৫২/২ যেহেতু এটির জন্য কোনও তৃতীয় পক্ষের লাইব্রেরি এবং ওয়ান-লাইনারের প্রয়োজন নেই।

— এমিল

কেবলমাত্র এই সাধারণ কাজটি সম্পাদনের জন্য কয়েকশ 'কেবি লাইব্রেরি কোড অন্তর্ভুক্ত করা প্রায় সঠিক জিনিস নয়।

— জেফ্রি ব্লাটম্যান

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

— শন প্যাট্রিক ফ্লয়েড

কোনও বিচ্ছেদের সাথে ফিরে আসতে কোনও উপায়?

— কুম্ভ শক্তি পাওয়ার

@ অ্যাকুরিয়াস পাওয়ারString.join(separator, arrayOrCollection)

— হোলার

Answer 4

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

for (String substring : Splitter.fixedLength(4).split(inputString)) {
    doSomethingWith(substring);
}

এবং এটি । হিসাবে সহজ!

Answer 5

public static String[] split(String src, int len) {
    String[] result = new String[(int)Math.ceil((double)src.length()/(double)len)];
    for (int i=0; i<result.length; i++)
        result[i] = src.substring(i*len, Math.min(src.length(), (i+1)*len));
    return result;
}

Comments

যেহেতু src.length()এবং lenউভয়ই হ'ল int, আপনার কলটি ceilingআপনি যা চান তা সম্পাদন করছে না - অন্যান্য প্রতিক্রিয়াগুলির মধ্যে এটি কীভাবে করছে তা দেখুন: (src.leth () + লেন - 1) / লেন

— মাইকেল ব্রুয়ার-ডেভিস

@ মিশেল: ভালো কথা। আমি এটি বহুবিধ দৈর্ঘ্যের স্ট্রিং দিয়ে পরীক্ষা করিনি। এটি এখন স্থির।

— সাউল

Answer 6

public String[] splitInParts(String s, int partLength)
{
    int len = s.length();

    // Number of parts
    int nparts = (len + partLength - 1) / partLength;
    String parts[] = new String[nparts];

    // Break into parts
    int offset= 0;
    int i = 0;
    while (i < nparts)
    {
        parts[i] = s.substring(offset, Math.min(offset + partLength, len));
        offset += partLength;
        i++;
    }

    return parts;
}

Comments

আগ্রহের বাইরে, আপনার কি forলুপগুলির বিরুদ্ধে কিছু আছে ?

— জন স্কিটি

একটি forলুপ প্রকৃতপক্ষে এর জন্য আরও 'প্রাকৃতিক' পছন্দ ব্যবহার :-) এটি নির্দেশ করার জন্য ধন্যবাদ।

— গ্রোড্রিগেজ

Answer 7

আপনি ব্যবহার করতে পারেন substringথেকে String.class(ব্যতিক্রম হ্যান্ডলিং) অথবা থেকে অ্যাপাচি ল্যাঙ কমন্স (এটা তোমার জন্য ব্যতিক্রম পরিচালনা)

static String   substring(String str, int start, int end) 

এটি একটি লুপের ভিতরে রাখুন এবং আপনি যেতে ভাল।

Comments

substringস্ট্যান্ডার্ড Stringক্লাসের পদ্ধতিতে কী ভুল ?

— গ্রোড্রিগেজ

কমন্স সংস্করণ ব্যতিক্রমগুলি এড়িয়ে চলেছে (সীমা ছাড়াই এবং এ জাতীয়)

— থিলো

আমি দেখি; আমি বলব পরিবর্তে কলিং কোডের পরামিতিগুলি নিয়ন্ত্রণ করে আমি 'ব্যতিক্রমগুলি এড়াতে' পছন্দ করি।

— গ্রোড্রিগেজ

Answer 8

আমি বরং এই সহজ সমাধান চাই:

String content = "Thequickbrownfoxjumps";
while(content.length() > 4) {
    System.out.println(content.substring(0, 4));
    content = content.substring(4);
}
System.out.println(content);

Comments

এটা করবেন না! স্ট্রিং অপরিবর্তনীয় তাই আপনার কোডটিতে প্রতি 4 টি অক্ষরে পুরো বাকী স্ট্রিংটি অনুলিপি করতে হবে। আপনার স্নিপেট স্ট্রিংয়ের আকারের ক্ষেত্রে লিনিয়ার সময়ের চেয়ে চতুর্ভুজ গ্রহণ করে।

— টোবিয়াস

@ টোবিয়াস: এমনকি স্ট্রিং পরিবর্তনীয় হলেও, এ সংক্রান্ত জটিল সংকলন প্রক্রিয়া বাদে এই স্নিপেটটি উল্লিখিত রিন্ডান্ট কপিটি করে। এই স্নিপেটটি ব্যবহারের একমাত্র কারণ হ'ল কোড সরলতা।

— চিতা কোডার

আপনি যখন আপনার কোডটি প্রথম পোস্ট করেছিলেন তখন থেকেই আপনি কি তা পরিবর্তন করেছিলেন? সর্বশেষতম সংস্করণটি আসলে অনুলিপিগুলি তৈরি করে না - সাবস্ট্রিং () দক্ষতার সাথে চালিত হয় (ধ্রুবক সময়, কমপক্ষে জাভার পুরানো সংস্করণে); এটি পুরো স্ট্রিংয়ের চরকে [] অন্তত জাভার পুরানো সংস্করণে) একটি রেফারেন্স রাখে, তবে আপনি সমস্ত অক্ষর রাখছেন বলে এই ক্ষেত্রে এটি ঠিক আছে। সুতরাং আপনার কাছে থাকা সর্বশেষ কোডটি আসলেই ঠিক আছে (বিষয়বস্তু খালি স্ট্রিং হিসাবে শুরু হয়ে গেলে আপনার কোডটি একটি খালি লাইন প্রিন্ট করে।

— টোবিয়াস

@ তোবিয়াস: আমার কোনও পরিবর্তন মনে নেই।

— চিতা কোডার

@ তোবিয়াস substringজাভা 7 এর সাথে বাস্তবায়ন পরিবর্তিত হয়েছে, ২০১২ এর মাঝামাঝি সময়ে জাভা থেকে ক্ষেত্রগুলি offsetএবং countক্ষেত্রগুলি সরিয়ে ফেলা হয়েছে update আপডেট করুন String। সুতরাং substringএই উত্তরটি তৈরি হওয়ার অনেক আগেই লিনিয়ারে পরিণত হওয়ার জটিলতা । উদাহরণস্বরূপ একটি ছোট স্ট্রিংয়ের জন্য, এটি এখনও যথেষ্ট দ্রুত এবং দীর্ঘতর স্ট্রিংয়ের জন্য চালিত হয় ... ভাল এই কাজটি অনুশীলনে খুব কমই ঘটে।

— হোলার

Answer 9

জাভা 8 স্ট্রিমগুলি ব্যবহার করে এখানে একটি লাইনার প্রয়োগকরণ রয়েছে:

String input = "Thequickbrownfoxjumps";
final AtomicInteger atomicInteger = new AtomicInteger(0);
Collection<String> result = input.chars()
                                    .mapToObj(c -> String.valueOf((char)c) )
                                    .collect(Collectors.groupingBy(c -> atomicInteger.getAndIncrement() / 4
                                                                ,Collectors.joining()))
                                    .values();

এটি নিম্নলিখিত আউটপুট দেয়:

[Theq, uick, brow, nfox, jump, s]

Comments

এটি একটি ভয়াবহ সমাধান, এপিআই-র উদ্দেশ্যটি নিয়ে লড়াই করা, রাষ্ট্রীয় ফাংশনগুলি ব্যবহার করে এবং একটি সাধারণ লুপের চেয়ে উল্লেখযোগ্যভাবে জটিল হওয়া, বক্সিং এবং স্ট্রিং কনক্যাটেনশন ওভারহেডের কথা না বলা। আপনি যদি স্ট্রিম সমাধান চান তবে এর মতো কিছু ব্যবহার করুনString[] result = IntStream.range(0, (input.length()+3)/4) .mapToObj(i -> input.substring(i *= 4, Math.min(i + 4, input.length()))) .toArray(String[]::new);

— হোলগার

Answer 10

স্লাইস সূচনার সূচকগুলি নির্ধারণ করতে জাভা 8 ইন্টারস্ট্রিম ব্যবহার করে যা এখানে একটি ওয়ান-লাইনার সংস্করণ রয়েছে :

String x = "Thequickbrownfoxjumps";

String[] result = IntStream
                    .iterate(0, i -> i + 4)
                    .limit((int) Math.ceil(x.length() / 4.0))
                    .mapToObj(i ->
                        x.substring(i, Math.min(i + 4, x.length())
                    )
                    .toArray(String[]::new);

Answer 11

আপনি যদি স্ট্রিংটি সমানভাবে পিছনের দিকে বিভক্ত করতে চান, যেমন ডান থেকে বামে, উদাহরণস্বরূপ , এখানে বিভক্ত 1010001111করতে [10, 1000, 1111]এখানে কোডটি:

/**
 * @param s         the string to be split
 * @param subLen    length of the equal-length substrings.
 * @param backwards true if the splitting is from right to left, false otherwise
 * @return an array of equal-length substrings
 * @throws ArithmeticException: / by zero when subLen == 0
 */
public static String[] split(String s, int subLen, boolean backwards) {
    assert s != null;
    int groups = s.length() % subLen == 0 ? s.length() / subLen : s.length() / subLen + 1;
    String[] strs = new String[groups];
    if (backwards) {
        for (int i = 0; i < groups; i++) {
            int beginIndex = s.length() - subLen * (i + 1);
            int endIndex = beginIndex + subLen;
            if (beginIndex < 0)
                beginIndex = 0;
            strs[groups - i - 1] = s.substring(beginIndex, endIndex);
        }
    } else {
        for (int i = 0; i < groups; i++) {
            int beginIndex = subLen * i;
            int endIndex = beginIndex + subLen;
            if (endIndex > s.length())
                endIndex = s.length();
            strs[i] = s.substring(beginIndex, endIndex);
        }
    }
    return strs;
}

Answer 12

আমি নিম্নলিখিত জাভা 8 সমাধান ব্যবহার:

public static List<String> splitString(final String string, final int chunkSize) {
  final int numberOfChunks = (string.length() + chunkSize - 1) / chunkSize;
  return IntStream.range(0, numberOfChunks)
                  .mapToObj(index -> string.substring(index * chunkSize, Math.min((index + 1) * chunkSize, string.length())))
                  .collect(toList());
}

Answer 13

জাভা 8 সমাধান (যেমন এই কিন্তু একটি বিট সহজ):

public static List<String> partition(String string, int partSize) {
  List<String> parts = IntStream.range(0, string.length() / partSize)
    .mapToObj(i -> string.substring(i * partSize, (i + 1) * partSize))
    .collect(toList());
  if ((string.length() % partSize) != 0)
    parts.add(string.substring(string.length() / partSize * partSize));
  return parts;
}

Answer 14

আমি গৃহীত সমাধানটির জন্য একটি মন্তব্যে @ অ্যালান মুরকে জিজ্ঞাসা করেছি কীভাবে নতুন সাথে স্ট্রিংগুলি পরিচালনা । তিনি ডটল ব্যবহার করার পরামর্শ দিয়েছিলেন।

তার পরামর্শটি ব্যবহার করে আমি কীভাবে এটি কাজ করে তার একটি ছোট নমুনা তৈরি করেছি:

public void regexDotAllExample() throws UnsupportedEncodingException {
    final String input = "The\nquick\nbrown\r\nfox\rjumps";
    final String regex = "(?<=\\G.{4})";

    Pattern splitByLengthPattern;
    String[] split;

    splitByLengthPattern = Pattern.compile(regex);
    split = splitByLengthPattern.split(input);
    System.out.println("---- Without DOTALL ----");
    for (int i = 0; i < split.length; i++) {
        byte[] s = split[i].getBytes("utf-8");
        System.out.println("[Idx: "+i+", length: "+s.length+"] - " + s);
    }
    /* Output is a single entry longer than the desired split size:
    ---- Without DOTALL ----
    [Idx: 0, length: 26] - [B@17cdc4a5
     */


    //DOTALL suggested in Alan Moores comment on SO: https://stackoverflow.com/a/3761521/1237974
    splitByLengthPattern = Pattern.compile(regex, Pattern.DOTALL);
    split = splitByLengthPattern.split(input);
    System.out.println("---- With DOTALL ----");
    for (int i = 0; i < split.length; i++) {
        byte[] s = split[i].getBytes("utf-8");
        System.out.println("[Idx: "+i+", length: "+s.length+"] - " + s);
    }
    /* Output is as desired 7 entries with each entry having a max length of 4:
    ---- With DOTALL ----
    [Idx: 0, length: 4] - [B@77b22abc
    [Idx: 1, length: 4] - [B@5213da08
    [Idx: 2, length: 4] - [B@154f6d51
    [Idx: 3, length: 4] - [B@1191ebc5
    [Idx: 4, length: 4] - [B@30ddb86
    [Idx: 5, length: 4] - [B@2c73bfb
    [Idx: 6, length: 2] - [B@6632dd29
     */

}

তবে আমি https://stackoverflow.com/a/3760193/1237974 এও @ জোন স্কিটির সমাধানটি পছন্দ করি । বৃহত্তর প্রকল্পগুলিতে রক্ষণাবেক্ষণের জন্য যেখানে নিয়মিত প্রকাশে সকলেই সমানভাবে অভিজ্ঞ না হয় আমি সম্ভবত জোনস সমাধানটি ব্যবহার করব।

Answer 15

আরেকটি নিষ্ঠুর শক্তি সমাধান হতে পারে,

    String input = "thequickbrownfoxjumps";
    int n = input.length()/4;
    String[] num = new String[n];

    for(int i = 0, x=0, y=4; i<n; i++){
    num[i]  = input.substring(x,y);
    x += 4;
    y += 4;
    System.out.println(num[i]);
    }

কোডটি কেবল সাবস্ট্রিং সহ স্ট্রিংয়ের মধ্য দিয়ে যায়

Answer 16

    import static java.lang.System.exit;
   import java.util.Scanner;
   import Java.util.Arrays.*;


 public class string123 {

public static void main(String[] args) {


  Scanner sc=new Scanner(System.in);
    System.out.println("Enter String");
    String r=sc.nextLine();
    String[] s=new String[10];
    int len=r.length();
       System.out.println("Enter length Of Sub-string");
    int l=sc.nextInt();
    int last;
    int f=0;
    for(int i=0;;i++){
        last=(f+l);
            if((last)>=len) last=len;
        s[i]=r.substring(f,last);
     // System.out.println(s[i]);

      if (last==len)break;
       f=(f+l);
    } 
    System.out.print(Arrays.tostring(s));
    }}

ফলাফল

 Enter String
 Thequickbrownfoxjumps
 Enter length Of Sub-string
 4

 ["Theq","uick","brow","nfox","jump","s"]

Answer 17

@Test
public void regexSplit() {
    String source = "Thequickbrownfoxjumps";
    // define matcher, any char, min length 1, max length 4
    Matcher matcher = Pattern.compile(".{1,4}").matcher(source);
    List<String> result = new ArrayList<>();
    while (matcher.find()) {
        result.add(source.substring(matcher.start(), matcher.end()));
    }
    String[] expected = {"Theq", "uick", "brow", "nfox", "jump", "s"};
    assertArrayEquals(result.toArray(), expected);
}

Answer 18

RegEx এবং জাভা 8 স্ট্রিমের উপর ভিত্তি করে আমার সংস্করণটি এখানে। Matcher.results()জাভা 9 সাল থেকে এটি উপলব্ধ যে উল্লেখ করা দরকার worth

পরীক্ষা অন্তর্ভুক্ত।

public static List<String> splitString(String input, int splitSize) {
    Matcher matcher = Pattern.compile("(?:(.{" + splitSize + "}))+?").matcher(input);
    return matcher.results().map(MatchResult::group).collect(Collectors.toList());
}

@Test
public void shouldSplitStringToEqualLengthParts() {
    String anyValidString = "Split me equally!";
    String[] expectedTokens2 = {"Sp", "li", "t ", "me", " e", "qu", "al", "ly"};
    String[] expectedTokens3 = {"Spl", "it ", "me ", "equ", "all"};

    Assert.assertArrayEquals(expectedTokens2, splitString(anyValidString, 2).toArray());
    Assert.assertArrayEquals(expectedTokens3, splitString(anyValidString, 3).toArray());
}

Answer 19

public static String[] split(String input, int length) throws IllegalArgumentException {

    if(length == 0 || input == null)
        return new String[0];

    int lengthD = length * 2;

    int size = input.length();
    if(size == 0)
        return new String[0];

    int rep = (int) Math.ceil(size * 1d / length);

    ByteArrayInputStream stream = new ByteArrayInputStream(input.getBytes(StandardCharsets.UTF_16LE));

    String[] out = new String[rep];
    byte[]  buf = new byte[lengthD];

    int d = 0;
    for (int i = 0; i < rep; i++) {

        try {
            d = stream.read(buf);
        } catch (IOException e) {
            e.printStackTrace();
        }

        if(d != lengthD)
        {
            out[i] = new String(buf,0,d, StandardCharsets.UTF_16LE);
            continue;
        }

        out[i] = new String(buf, StandardCharsets.UTF_16LE);
    }
    return out;
}

Answer 20

public static List<String> getSplittedString(String stringtoSplit,
            int length) {

        List<String> returnStringList = new ArrayList<String>(
                (stringtoSplit.length() + length - 1) / length);

        for (int start = 0; start < stringtoSplit.length(); start += length) {
            returnStringList.add(stringtoSplit.substring(start,
                    Math.min(stringtoSplit.length(), start + length)));
        }

        return returnStringList;
    }