जावा में बराबर लंबाई वाले सबस्ट्रिंग के लिए स्प्लिट स्ट्रिंग

Question

"Thequickbrownfoxjumps"जावा में समान आकार के सब्सट्रिंग के लिए स्ट्रिंग को कैसे विभाजित किया जाए । उदाहरण के लिए। "Thequickbrownfoxjumps"4 के बराबर आकार आउटपुट देना चाहिए।

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

इसी तरह का प्रश्न:

स्केला में बराबर-लंबाई वाले पदार्थों में विभाजित स्ट्रिंग

Comments

आपने क्या प्रयास किया? वह काम क्यों नहीं किया?

— थिलो सेप

क्या आपको इसके लिए regex का उपयोग करने की आवश्यकता है? रेगेक्स टैग की वजह से ही पूछ रहा

— हूं

@ थिलो लिंक जो उसने पोस्ट किया है वह स्काला के लिए है, वह जावा में उसी के बारे में पूछ रहा है

— जयदीप पटेल

@ थिलो: मैं पूछ रहा था कि जावा में इसे कैसे करना है, जैसे कि स्कैला के लिए दिया गया उत्तर।

— एमिल

Answer 1

यहाँ रेगेक्स वन-लाइनर संस्करण है:

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

\Gएक शून्य-चौड़ाई का दावा है जो उस स्थिति से मेल खाता है जहां पिछला मैच समाप्त हुआ था। यदि कोई पिछला मैच नहीं था , तो यह इनपुट की शुरुआत से मेल खाता है, जैसा कि\A । पिछले मैच के अंत से चार अक्षरों के साथ स्थिति को देखने वाला संलग्नक मेल खाता है।

दोनों दिखावे और \Gउन्नत regex विशेषताएं हैं, सभी स्वादों द्वारा समर्थित नहीं हैं। इसके अलावा, \Gइसका समर्थन करने वाले स्वादों पर लगातार लागू नहीं किया जाता है। यह ट्रिक Java (पर्ल), .NET और JGSoft में (उदाहरण के लिए) काम करेगी, लेकिन इसमें नहीं PHP (PCRE), रूबी 1.9+ या टेक्स्टमैट (ओनिगुरुमा) में नहीं। जावास्क्रिप्ट का /y(चिपचिपा झंडा) उतना लचीला नहीं है \G, और इस तरह भी इस्तेमाल नहीं किया जा सकता है, भले ही जेएस ने समर्थन किया हो।

मुझे यह उल्लेख करना चाहिए कि यदि आपके पास अन्य विकल्प हैं, तो मैं जरूरी नहीं कि इस समाधान की सिफारिश करूं । अन्य उत्तरों में गैर-रेगेक्स समाधान लंबे समय तक हो सकते हैं, लेकिन वे स्वयं-दस्तावेज भी हैं; यह ठीक इसके विपरीत है है। ;)

इसके अलावा, यह एंड्रॉइड में काम नहीं करता है, जो \Gलुकबाइंड के उपयोग का समर्थन नहीं करता है ।

Comments

PHP 5.2.4 में निम्नलिखित कोड काम करता है: वापस प्रीग_स्प्लिट ('/ (<? \ _ G। {$ $ Len।'}) / U ', $ str, -1, PREG_SPLIT_NO_EMPTY);

— इगोर

रिकॉर्ड के लिए, String.substring()रेगेक्स के बजाय, कोड की कुछ अतिरिक्त पंक्तियों की आवश्यकता होने पर, 5x के क्रम पर कहीं तेज गति से चलेगा ...

— drew moore

जावा में यह newlines के साथ एक स्ट्रिंग के लिए काम नहीं करता है। यह केवल पहली न्यूलाइन तक की जांच करेगा, और यदि वह न्यूलाइन विभाजन-आकार से पहले होता है, तो स्ट्रिंग विभाजित नहीं होगी। या मुझसे कोई चीज चूक रही है?

— जोसेनसन 22

संपूर्णता की खातिर: बहुस्तरीय पर बंटवारे के पाठ (?s)को रेगेक्स में एक उपसर्ग की आवश्यकता होती है (?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;
}

मुझे नहीं लगता कि यह वास्तव में इस के लिए एक regex का उपयोग करने के लायक है।

संपादित करें: एक regex का उपयोग नहीं करने के लिए मेरा तर्क:

• यह regexes के असली पैटर्न के किसी भी मिलान का उपयोग नहीं करता है। अभी गिनती है।
• मुझे संदेह है कि उपरोक्त अधिक कुशल होगा, हालांकि अधिकांश मामलों में यह मायने नहीं रखेगा
• यदि आपको विभिन्न स्थानों में चर आकार का उपयोग करने की आवश्यकता है, तो आपको या तो पैरामीटर के आधार पर regex का निर्माण करने के लिए पुनरावृत्ति या एक सहायक फ़ंक्शन मिला है।
• एक और जवाब में प्रदान की गई रेगेक्स ने सबसे पहले (अवैध भागने) को संकलित नहीं किया, और फिर काम नहीं किया। मेरे कोड ने पहली बार काम किया। यह सादा कोड, IMO, regexes की प्रयोज्य के लिए एक वसीयतनामा है।

Comments

@ ईमिल: वास्तव में, आप एक regex के लिए नहीं पूछा। यह टैग में है, लेकिन सवाल में कुछ भी नहीं खुद के लिए एक regex पूछता है। आप इस विधि को एक स्थान पर रखते हैं, और फिर आप अपने कोड में कहीं भी केवल एक बहुत ही पठनीय विवरण में स्ट्रिंग को विभाजित कर सकते हैं ।

— जॉन स्कीट

एमिल यह वह नहीं है जो एक रेगीक्स के लिए है। अवधि।

— क्रिस

@Emil: यदि आप स्ट्रिंग को विभाजित करने के लिए एक-लाइनर चाहते हैं, तो मैं Splitter.fixedLength(4)सुझाता हूँ कि अमरूद का सुझाव सीनियर द्वारा दिया गया है।

— कॉलिनडे

@ जय: आने पर आपको व्यंग्यात्मक होने की आवश्यकता नहीं है। मुझे यकीन है कि यह केवल एक-पंक्ति में regex का उपयोग करके किया जा सकता है। निश्चित लंबाई उप-स्ट्रिंग भी एक पैटर्न है। आप इस उत्तर के बारे में क्या कहते हैं। stackoverflow.com/questions/3760152/… ।

— Emil

@ ईमिल: मेरा इरादा यह नहीं था कि असभ्य हो, सिर्फ सनकी हो। मेरी बात का गंभीर हिस्सा यह था कि हाँ, मुझे यकीन है कि आप ऐसा करने के लिए एक रेगेक्स के साथ आ सकते हैं - मुझे लगता है कि एलन मूर के पास एक है जो दावा करता है कि वह काम करता है - यह गुप्त है और इसलिए बाद के प्रोग्रामर के लिए मुश्किल है समझें और बनाए रखें। एक विकल्प समाधान सहज और पठनीय हो सकता है। जॉन स्कीट की चौथी बुलेट देखें: मैं उस 100% से सहमत हूं।

— जे

Answer 3

Google अमरूद के साथ यह बहुत आसान है :

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

पोस्ट के लिए धन्यवाद (अमरूद लाइब्रेरी विधि से मुझे अवगत कराने के लिए)। लेकिन मुझे regex उत्तर stackoverflow.com/questions/3760152/ ... को स्वीकार करना होगा क्योंकि इसके लिए किसी भी 3 पार्टी लाइब्रेरी और एक-लाइनर की आवश्यकता नहीं है।

— एमिल

इस सरल कार्य को करने के लिए सिर्फ लाइब्रेरी कोड के सैकड़ों KB को शामिल करना लगभग निश्चित रूप से सही बात नहीं है।

— जेफरी ब्लाटमैन

@JeffreyBlattman सहित अमरूद सिर्फ इसके लिए शायद overkill, सच है। लेकिन मैं इसे वैसे भी अपने सभी जावा कोड में एक सामान्य-उद्देश्य पुस्तकालय के रूप में उपयोग करता हूं, इसलिए इस कार्यक्षमता के एक अतिरिक्त टुकड़े का उपयोग क्यों न करें

— शॉन पैट्रिक फ्लॉयड

किसी विभाजक के साथ वापस जुड़ने का कोई तरीका?

— कुंभ राशि

@AquariusPowerString.join(separator, arrayOrCollection)

— होल्गर

Answer 4

यदि आप Google के अमरूद के सामान्य-उद्देश्य वाले पुस्तकालयों का उपयोग कर रहे हैं (और काफी ईमानदारी से, कोई भी नया जावा प्रोजेक्ट शायद होना चाहिए), तो यह फाड़नेवाला वर्ग के साथ तुच्छ है :

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.length () + लेन - 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 वर्णों के पूरे शेष स्ट्रिंग की प्रतिलिपि बनाने की आवश्यकता है। इसलिए आपका स्निपेट स्ट्रिंग के आकार में रैखिक समय के बजाय द्विघात लेता है।

— तोबियास

@ टोबियास: अगर स्ट्रिंग उत्परिवर्तनीय थी, तब भी यह स्निपेट उल्लेखित निरर्थक प्रतिलिपि करता है, सिवाय इसके कि इसके बारे में जटिल संकलन प्रक्रियाएं हों। इस स्निपेट का उपयोग करने का एकमात्र कारण कोड सादगी है।

— चीता कोडर

जब आपने पहली बार पोस्ट किया था तब आपने अपना कोड बदल दिया था? नवीनतम संस्करण वास्तव में प्रतियां नहीं बनाते हैं - प्रतिस्थापन () कुशलता से चलता है (निरंतर समय, कम से कम जावा के पुराने संस्करणों पर); यह पूरे स्ट्रिंग के चार [] (कम से कम जावा के पुराने संस्करणों पर) का संदर्भ रखता है, लेकिन इस मामले में ठीक है क्योंकि आप सभी पात्रों को रख रहे हैं। इसलिए आपके पास यहां जो नवीनतम कोड है, वह वास्तव में ठीक है (मोडुलो कि आपका कोड एक खाली लाइन को प्रिंट करता है यदि सामग्री खाली स्ट्रिंग के रूप में शुरू होती है, जो कि हो सकता है कि कोई भी नहीं हो)।

— तोबियास

@ टोबियास: मुझे कोई बदलाव याद नहीं है।

— चीता कोडर

@Tobias substringकार्यान्वयन जावा 7, 2012 के मध्य में अद्यतन 6, जब साथ बदला offsetऔर countक्षेत्रों से हटा दिया गया Stringवर्ग। तो substringइस उत्तर के बनने से बहुत पहले ही रेखीय में बदल गया। उदाहरण के लिए एक छोटे से तार के लिए, यह अभी भी काफी तेजी से और लंबे समय तक तार के लिए चलता है ... अच्छी तरह से यह कार्य शायद ही कभी अभ्यास में होता है।

— होल्गर

Answer 9

यहाँ Java8 धाराओं का उपयोग करते हुए एक लाइनर कार्यान्वयन है:

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);

— Holger

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

मैंने @Alan मूर से एक टिप्पणी में स्वीकार किए गए समाधान के बारे में पूछा कि कैसे नई कहानियों के साथ तार को संभाला जा सकता है। उन्होंने DOTALL का उपयोग करने का सुझाव दिया।

उनके सुझाव का उपयोग करते हुए मैंने एक छोटा सा नमूना बनाया कि यह कैसे काम करता है:

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 पर @Jon Skeets solution भी पसंद है। बड़ी परियोजनाओं में स्थिरता के लिए जहां हर कोई नियमित रूप से समान रूप से अनुभवी नहीं होता है, मैं शायद जोंस समाधान का उपयोग करूंगा।

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 और Java 8 स्ट्रीम पर आधारित है। यह उल्लेख के लायक है कि Matcher.results()जावा 9 के बाद से यह विधि उपलब्ध है।

टेस्ट शामिल थे।

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;
    }