Split string ke substring dengan panjang yang sama di Jawa

Cara membagi string "Thequickbrownfoxjumps"ke substring dengan ukuran yang sama di Jawa. Misalnya. "Thequickbrownfoxjumps"dari 4 ukuran yang sama harus memberikan output.

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

Pertanyaan serupa:

Pisahkan string menjadi substring dengan panjang yang sama di Scala

Berikut versi satu-baris regex:

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

\Gadalah pernyataan nol-lebar yang cocok dengan posisi di mana pertandingan sebelumnya berakhir. Jika ada itu tidak ada pertandingan sebelumnya, cocok dengan awal input, sama seperti \A. Tampilan terlampir di belakang cocok dengan posisi yang terdiri dari empat karakter sejak akhir pertandingan terakhir.

Keduanya terlihat di belakang dan \Gmerupakan fitur regex canggih, tidak didukung oleh semua rasa. Selain itu, \Gtidak diterapkan secara konsisten di seluruh rasa yang mendukungnya. Trik ini akan berfungsi (misalnya) di Java , Perl, .NET dan JGSoft, tetapi tidak dalam PHP (PCRE), Ruby 1.9+ atau TextMate (keduanya Oniguruma). JavaScript /y(flag lengket) tidak sefleksibel \G, dan tidak dapat digunakan dengan cara ini meskipun JS memang mendukung tampilan di belakang.

Saya harus menyebutkan bahwa saya tidak selalu merekomendasikan solusi ini jika Anda memiliki opsi lain. Solusi non-regex dalam jawaban lain mungkin lebih lama, tetapi mereka juga mendokumentasikan diri sendiri; ini hanya kebalikan dari itu. ;)

Juga, ini tidak berfungsi di Android, yang tidak mendukung penggunaan tampilan \Gdi belakang.

Yah, cukup mudah untuk melakukan ini dengan operasi aritmatika dan string sederhana:

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

Saya tidak berpikir itu benar-benar layak menggunakan regex untuk ini.

EDIT: Alasan saya untuk tidak menggunakan regex:

• Ini tidak menggunakan salah satu dari pencocokan pola nyata regex. Itu hanya menghitung.
• Saya menduga hal di atas akan lebih efisien, meskipun dalam kebanyakan kasus itu tidak masalah
• Jika Anda perlu menggunakan ukuran variabel di tempat yang berbeda, Anda memiliki pengulangan atau fungsi pembantu untuk membangun regex itu sendiri berdasarkan parameter - ick.
• Regex yang disediakan dalam jawaban lain pertama tidak dikompilasi (melarikan diri tidak valid), dan kemudian tidak berhasil. Kode saya berfungsi pertama kali. Itu lebih merupakan bukti kegunaan regex vs kode biasa, IMO.

Ini sangat mudah dengan Google Guava :

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

Keluaran:

Theq
uick
brow
nfox
jump
s

Atau jika Anda membutuhkan hasilnya sebagai array, Anda dapat menggunakan kode ini:

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

Referensi:

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

Catatan: Konstruksi splitter ditunjukkan pada baris di atas, tetapi karena Splitter tidak dapat diubah dan dapat digunakan kembali, itu praktik yang baik untuk menyimpannya dalam konstanta:

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

// more code

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

Jika Anda menggunakan perpustakaan serba guna jambu Google (dan sejujurnya, proyek Java baru mana pun seharusnya ), ini adalah hal sepele yang gila dengan kelas Splitter :

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

dan hanya itu . Semudah!

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

Anda dapat menggunakan substringdari String.class(menangani pengecualian) atau dari Apache lang commons (ini menangani pengecualian untuk Anda)

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

Letakkan di dalam lingkaran dan Anda siap melakukannya.

Saya lebih suka solusi sederhana ini:

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

Berikut ini adalah implementasi satu liner menggunakan stream 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();

Ini memberikan output sebagai berikut:

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

Berikut ini adalah versi satu-baris yang menggunakan Java 8 IntStream untuk menentukan indeks awal irisan:

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

Jika Anda ingin membagi string sama mundur, yaitu dari kanan ke kiri, misalnya untuk membagi 1010001111ke [10, 1000, 1111], inilah kodenya:

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

saya menggunakan solusi java 8 berikut:

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

Solusi Java 8 (seperti ini tetapi sedikit lebih sederhana):

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

Saya bertanya kepada @Alan Moore dalam sebuah komentar atas solusi yang diterima bagaimana string dengan baris baru dapat ditangani. Dia menyarankan menggunakan DOTALL.

Menggunakan sarannya, saya membuat sampel kecil bagaimana itu bekerja:

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

}

Tapi saya suka solusi @Jon Skeets di https://stackoverflow.com/a/3760193/1237974 juga. Untuk pemeliharaan dalam proyek yang lebih besar di mana tidak semua orang sama-sama berpengalaman dalam ekspresi reguler, saya mungkin akan menggunakan solusi Jons.

Solusi brute force lainnya adalah,

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

Di mana kode hanya melangkah melalui string dengan substring

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

Hasil

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

Ini adalah versi saya berdasarkan aliran RegEx dan Java 8. Perlu disebutkan bahwa Matcher.results()metode ini tersedia sejak Java 9.

Tes disertakan.

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