n번째 문자마다 문자열 분할

n번째 문자마다 문자열 분할

JavaScript에서는 3번째 문자마다 문자열을 분할할 수 있습니다.

"foobarspam".match(/.{1,3}/g)

자바에서 이걸 어떻게 하는지 알아보고 있어요.조언 좀 해주시겠어요?

다음과 같이 할 수 있습니다.

String s = "1234567890";
System.out.println(java.util.Arrays.toString(s.split("(?<=\\G...)")));

그 결과, 다음과 같이 됩니다.

[123, 456, 789, 0]

" " "(?<=\G...)는 마지막 일치가 있는 빈 문자열과 일치합니다(\G) 뒤에 3글자 ( )가 붙습니다....그 전에 ( )(?<= ))

Java는 완전한 기능을 갖춘 분할 유틸리티를 제공하지 않기 때문에 Guava 라이브러리는 다음을 수행합니다.

Iterable<String> pieces = Splitter.fixedLength(3).split(string);

Javadoc for Splitter를 확인해 보십시오. 매우 강력합니다.

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        for (String part : getParts("foobarspam", 3)) {
            System.out.println(part);
        }
    }
    private static List<String> getParts(String string, int partitionSize) {
        List<String> parts = new ArrayList<String>();
        int len = string.length();
        for (int i=0; i<len; i+=partitionSize)
        {
            parts.add(string.substring(i, Math.min(len, i + partitionSize)));
        }
        return parts;
    }
}

Bart Kiers의 답변과 더불어 3개의 도트를 사용하는 대신 가능하다고 덧붙이고 싶습니다.... 세 에서는 3자, 3자, 3자, 3자, 3자, 3자, 3자, 3자, 3자, 3자, 3자, 3자, 3자, 3자, 3자, 3자 쓰면 됩니다..{3}같은 의미입니다.

그 후 코드는 다음과 같습니다.

String bitstream = "00101010001001010100101010100101010101001010100001010101010010101";
System.out.println(java.util.Arrays.toString(bitstream.split("(?<=\\G.{3})")));

이렇게 하면 문자열 길이를 쉽게 변경할 수 있으며 함수 작성은 가변 입력 문자열 길이로 합리적입니다.이것은 다음과 같이 실행할 수 있습니다.

public static String[] splitAfterNChars(String input, int splitLen){
    return input.split(String.format("(?<=\\G.{%1$d})", splitLen));
}

IdeOne의 예: http://ideone.com/rNlTj5

레이트 엔트리

Java8 스트림을 사용한 간결한 실장은 다음과 같습니다.하나의 라이너입니다.

String foobarspam = "foobarspam";
AtomicInteger splitCounter = new AtomicInteger(0);
Collection<String> splittedStrings = foobarspam
                                    .chars()
                                    .mapToObj(_char -> String.valueOf((char)_char))
                                    .collect(Collectors.groupingBy(stringChar -> splitCounter.getAndIncrement() / 3
                                                                ,Collectors.joining()))
                                    .values();

출력:

[foo, bar, spa, m]

이 답변은 늦었지만, 어쨌든 새로운 프로그래머가 알 수 있도록 발표하겠습니다.

정규 표현을 사용하지 않고 서드파티 라이브러리에 의존하지 않는 경우 대신 이 방법을 사용할 수 있습니다.이 방법은 2.80GHz CPU로 89920 ~100113나노초(1밀리초 미만) 소요됩니다.Simon Nickerson의 예처럼 예쁘지는 않지만 효과가 있습니다.

   /**
     * Divides the given string into substrings each consisting of the provided
     * length(s).
     * 
     * @param string
     *            the string to split.
     * @param defaultLength
     *            the default length used for any extra substrings. If set to
     *            <code>0</code>, the last substring will start at the sum of
     *            <code>lengths</code> and end at the end of <code>string</code>.
     * @param lengths
     *            the lengths of each substring in order. If any substring is not
     *            provided a length, it will use <code>defaultLength</code>.
     * @return the array of strings computed by splitting this string into the given
     *         substring lengths.
     */
    public static String[] divideString(String string, int defaultLength, int... lengths) {
        java.util.ArrayList<String> parts = new java.util.ArrayList<String>();

        if (lengths.length == 0) {
            parts.add(string.substring(0, defaultLength));
            string = string.substring(defaultLength);
            while (string.length() > 0) {
                if (string.length() < defaultLength) {
                    parts.add(string);
                    break;
                }
                parts.add(string.substring(0, defaultLength));
                string = string.substring(defaultLength);
            }
        } else {
            for (int i = 0, temp; i < lengths.length; i++) {
                temp = lengths[i];
                if (string.length() < temp) {
                    parts.add(string);
                    break;
                }
                parts.add(string.substring(0, temp));
                string = string.substring(temp);
            }
            while (string.length() > 0) {
                if (string.length() < defaultLength || defaultLength <= 0) {
                    parts.add(string);
                    break;
                }
                parts.add(string.substring(0, defaultLength));
                string = string.substring(defaultLength);
            }
        }

        return parts.toArray(new String[parts.size()]);
    }

플레인 자바 사용:

    String s = "1234567890";
    List<String> list = new Scanner(s).findAll("...").map(MatchResult::group).collect(Collectors.toList());
    System.out.printf("%s%n", list);

출력을 생성합니다.

[123, 456, 789]

남은 문자(이 경우 0)는 폐기됩니다.

n번째 문자마다 문자열을 분할하여 목록 각 인덱스에 넣을 수도 있습니다.

여기서는 Sequence라는 이름의 문자열 목록을 만들었습니다.

리스트 < String >

그럼 기본적으로 스트링 "KILOOSO"를 두 단어마다 나눠요.따라서 'KI' 'LO' 'SO'는 시퀀스라는 목록의 별도 색인에 통합됩니다.

문자열 S = KILOSO

시퀀스 = Arrays.asList(S.split("")<=\G)..)"));

그래서 하고 있을 때:

System.out.print(시퀀스)

다음과 같이 인쇄됩니다.

[KI, LO, SO]

다음을 쓸 수 있는지 확인합니다.

System.out.print(시퀀스.get(1)

다음과 같이 인쇄됩니다.

LO

최근에 이 문제가 발생했습니다.다음은 제가 생각해낸 해결책입니다.

final int LENGTH = 10;
String test = "Here is a very long description, it is going to be past 10";

Map<Integer,StringBuilder> stringBuilderMap = new HashMap<>();
for ( int i = 0; i < test.length(); i++ ) {
    int position = i / LENGTH; // i<10 then 0, 10<=i<19 then 1, 20<=i<30 then 2, etc.

    StringBuilder currentSb = stringBuilderMap.computeIfAbsent( position, pos -> new StringBuilder() ); // find sb, or create one if not present
    currentSb.append( test.charAt( i ) ); // add the current char to our sb
}

List<String> comments = stringBuilderMap.entrySet().stream()
        .sorted( Comparator.comparing( Map.Entry::getKey ) )
        .map( entrySet -> entrySet.getValue().toString() )
        .collect( Collectors.toList() );
//done



// here you can see the data
comments.forEach( cmt -> System.out.println( String.format( "'%s' ... length= %d", cmt, cmt.length() ) ) );
// PRINTS:
// 'Here is a ' ... length= 10
// 'very long ' ... length= 10
// 'descriptio' ... length= 10
// 'n, it is g' ... length= 10
// 'oing to be' ... length= 10
// ' past 10' ... length= 8

// make sure they are equal
String joinedString = String.join( "", comments );
System.out.println( "\nOriginal strings are equal " + joinedString.equals( test ) );
// PRINTS: Original strings are equal true

저는 이런 것부터 시작할까?

public List<String> split(String str, int interval) {
    if (str.length() <= interval) {
        return List.of(str);
    }
    var subStrings = new ArrayList<String>();
    int pointer = 0;
    while (str.length() > pointer) {
        String substring = str.substring(pointer, pointer + interval);
        subStrings.add(substring);
        pointer += interval;
    }
    return subStrings;
}

언급URL : https://stackoverflow.com/questions/2297347/splitting-a-string-at-every-n-th-character