Teilen Sie die Zeichenfolge in Java in Teilzeichenfolgen gleicher Länge

So teilen Sie den String "Thequickbrownfoxjumps"in Java in gleich große Teilzeichenfolgen. Z.B. "Thequickbrownfoxjumps"von 4 gleicher Größe sollte die Ausgabe geben.

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

Ähnliche Frage:

Teilen Sie die Zeichenfolge in Scala in gleichlange Teilzeichenfolgen auf

Hier ist die Regex-Einzeiler-Version:

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

\Gist eine Behauptung mit einer Breite von Null, die mit der Position übereinstimmt, an der die vorherige Übereinstimmung beendet wurde. Wenn es war kein vorheriges Spiel, paßt es den Beginn des Eingangs, das gleiches wie \A. Das beiliegende Erscheinungsbild entspricht der Position, die vier Zeichen vom Ende der letzten Übereinstimmung entfernt ist.

Beide sehen gut aus und \Gsind erweiterte Regex-Funktionen, die nicht von allen Geschmacksrichtungen unterstützt werden. Darüber hinaus \Gwird nicht konsistent über die Geschmacksrichtungen implementiert, die es unterstützen. Dieser Trick funktioniert (zum Beispiel) in Java , Perl, .NET und JGSoft, jedoch nicht in PHP (PCRE), Ruby 1.9+ oder TextMate (beide Oniguruma). JavaScript /y(Sticky Flag) ist nicht so flexibel wie \Gund kann auf diese Weise nicht verwendet werden, selbst wenn JS Lookbehind unterstützt.

Ich sollte erwähnen, dass ich diese Lösung nicht unbedingt empfehle , wenn Sie andere Optionen haben. Die Nicht-Regex-Lösungen in den anderen Antworten sind möglicherweise länger, aber sie dokumentieren sich auch selbst. Dies ist genau das Gegenteil davon. ;)

Dies funktioniert auch nicht in Android, was die Verwendung \Gin Lookbehinds nicht unterstützt .

Nun, es ist ziemlich einfach, dies mit einfachen Arithmetik- und String-Operationen zu tun:

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

Ich denke nicht, dass es sich wirklich lohnt, einen regulären Ausdruck dafür zu verwenden.

EDIT: Meine Argumentation für die Verwendung eines regulären Ausdrucks:

• Dies verwendet keinen der realen Mustervergleiche von Regexen. Es zählt nur.
• Ich vermute, dass das oben Genannte effizienter ist, obwohl es in den meisten Fällen keine Rolle spielt
• Wenn Sie an verschiedenen Stellen variable Größen verwenden müssen, haben Sie entweder eine Wiederholung oder eine Hilfsfunktion, um den regulären Ausdruck selbst basierend auf einem Parameter zu erstellen.
• Der in einer anderen Antwort angegebene reguläre Ausdruck wurde zunächst nicht kompiliert (ungültiges Escapezeichen) und funktionierte dann nicht. Mein Code hat beim ersten Mal funktioniert. Dies ist eher ein Beweis für die Verwendbarkeit von regulären Ausdrücken im Vergleich zu einfachem Code, IMO.

Dies ist mit Google Guava sehr einfach :

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

Ausgabe:

Theq
uick
brow
nfox
jump
s

Wenn Sie das Ergebnis als Array benötigen, können Sie diesen Code verwenden:

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

Referenz:

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

Hinweis: Die Splitterkonstruktion ist oben inline dargestellt. Da Splitter jedoch unveränderlich und wiederverwendbar sind, empfiehlt es sich, sie in Konstanten zu speichern:

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

// more code

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

Wenn Sie die Guaven -Allzweckbibliotheken von Google verwenden (und ganz ehrlich, jedes neue Java-Projekt sollte es wahrscheinlich sein), ist dies mit der Splitter- Klasse wahnsinnig trivial :

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

und das wars . Einfach wie!

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

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

Sie können substringvon String.class(Behandlung von Ausnahmen) oder von Apache lang Commons (es behandelt Ausnahmen für Sie) verwenden.

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

Legen Sie es in eine Schleife und Sie können loslegen.

Ich hätte lieber diese einfache Lösung:

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

Hier ist eine Einzeiler-Implementierung mit Java8-Streams:

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

Es gibt die folgende Ausgabe:

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

Hier ist ein Einzeiler - Version , die verwendet Java 8 IntStream die Indizes der Scheibe Anfänge zu bestimmen:

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

Im Fall , dass Sie die Zeichenfolge gleich nach hinten, also von rechts nach links, zum Beispiel spalten, zu spalten 1010001111zu [10, 1000, 1111], hier ist der Code:

/**
 * @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;
}

Ich benutze die folgende Java 8-Lösung:

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

Java 8-Lösung ( so, aber etwas einfacher):

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

Ich fragte @Alan Moore in einem Kommentar zur akzeptierten Lösung, wie Zeichenfolgen mit Zeilenumbrüchen behandelt werden könnten. Er schlug vor, DOTALL zu verwenden.

Mit seinem Vorschlag habe ich eine kleine Auswahl erstellt, wie das funktioniert:

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
     */

}

Aber ich mag auch die @ Jon Skeets-Lösung in https://stackoverflow.com/a/3760193/1237974 . Für die Wartbarkeit in größeren Projekten, in denen nicht jeder gleichermaßen Erfahrung mit regulären Ausdrücken hat, würde ich wahrscheinlich die Jons-Lösung verwenden.

Eine andere Brute-Force-Lösung könnte sein:

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

Wobei der Code nur mit Teilzeichenfolgen durch die Zeichenfolge tritt

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

Ergebnis

 Enter String
 Thequickbrownfoxjumps
 Enter length Of Sub-string
 4

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

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

Hier ist meine Version, die auf RegEx- und Java 8-Streams basiert. Es ist erwähnenswert, dass die Matcher.results()Methode seit Java 9 verfügbar ist.

Test enthalten.

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

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

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