Разбить строку на подстроки равной длины в Java
Как разбить строку "Thequickbrownfoxjumps" на подстроки равного размера в Java. Например. "Thequickbrownfoxjumps" 4 равных размера должны дать вывод.
["Theq","uick","brow","nfox","jump","s"]
Подобный вопрос:
23 ответа
Вот регулярная версия с одной строкой:
System.out.println(Arrays.toString(
"Thequickbrownfoxjumps".split("(?<=\\G.{4})")
));
\G является утверждением нулевой ширины, которое соответствует позиции, где закончилось предыдущее совпадение. Если не было предыдущего совпадения, оно совпадает с началом ввода, так же как \A, Вложенный внешний вид соответствует позиции, которая находится на расстоянии четырех символов от конца последнего соответствия.
И смотреть назад и \G Расширенные функции регулярных выражений, которые поддерживаются не всеми разновидностями. Более того, \G не реализован последовательно во всех разновидностях, которые его поддерживают. Этот прием будет работать (например) в Java, Perl,.NET и JGSoft, но не в PHP (PCRE), Ruby 1.9+ или TextMate (оба Oniguruma). в JavaScript /y (липкий флаг) не так гибок, как \Gи не может быть использован таким образом, даже если JS поддерживает lookhehind.
Я должен отметить, что я не обязательно рекомендую это решение, если у вас есть другие варианты. Решения без регулярных выражений в других ответах могут быть длиннее, но они также самодокументированы; это примерно противоположность этому.;)
Кроме того, это не работает в Android, который не поддерживает использование \G во взглядах
Ну, это довольно легко сделать грубой силой:
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;
}
Я не думаю, что это действительно стоит использовать регулярное выражение для этого.
РЕДАКТИРОВАТЬ: Моя причина не использовать регулярное выражение:
- Это не использует никакого реального сопоставления с образцом регулярных выражений. Это просто подсчет.
- Я подозреваю, что вышеупомянутое будет более эффективным, хотя в большинстве случаев это не будет иметь значения
- Если вам нужно использовать переменные размеры в разных местах, у вас либо есть повторение, либо вспомогательная функция для построения самого регулярного выражения на основе параметра - ick.
- Регулярное выражение, приведенное в другом ответе, сначала не компилировалось (недопустимое экранирование), а затем не работало. Мой код работал с первого раза. Это больше свидетельствует об удобстве использования регулярных выражений по сравнению с простым кодом, IMO.
Это очень легко с Google Guava:
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);
}
Если вы используете библиотеки общего назначения guava от Google (и, честно говоря, любой новый проект Java, вероятно, должен быть), это безумно тривиально с классом Splitter:
for (String substring : Splitter.fixedLength(4).split(inputString)) {
doSomethingWith(substring);
}
и это все. Легко как!
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;
}
Вот однострочная версия, которая использует Java 8 IntStream для определения индексов начала среза:
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);
Ты можешь использовать substring от String.class (обработка исключений) или из Apache lang commons (он обрабатывает исключения для вас)
static String substring(String str, int start, int end)
Поместите это в петлю, и все готово.
А
StringBuilder версия:
public static List<String> getChunks(String s, int chunkSize)
{
List<String> chunks = new ArrayList<>();
StringBuilder sb = new StringBuilder(s);
while(!(sb.length() ==0))
{
chunks.add(sb.substring(0, chunkSize));
sb.delete(0, chunkSize);
}
return chunks;
}
Я бы предпочел это простое решение:
String content = "Thequickbrownfoxjumps";
while(content.length() > 4) {
System.out.println(content.substring(0, 4));
content = content.substring(4);
}
System.out.println(content);
Вот одна реализация лайнера, использующая потоки 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]
Я использую следующее решение Java 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());
}
Используйте кодовые точки для обработки всех символов
Вот решение:
- Работает со всеми 143,859 Unicode символов
- Позволяет вам исследовать или изменять каждую результирующую строку, если у вас есть дальнейшая логика для обработки.
Чтобы работать со всеми символами Unicode, избегайте устаревшего типа. И избегать
char-на базе коммунальных услуг. Вместо этого используйте целые числа кодовой точки .
Вызов String#codePoints получить IntStreamобъект, поток значений. В приведенном ниже коде мы собираем эти
intзначения в массив. Затем мы зацикливаем массив, для каждого целого числа мы добавляем символ, присвоенный этому числу, к нашемуобъект. Каждый n-й символ мы добавляем строку в наш главный список и очищаем
StringBuilder.
String input = "Thequickbrownfoxjumps";
int chunkSize = 4 ;
int[] codePoints = input.codePoints().toArray(); // `String#codePoints` returns an `IntStream`. Collect the elements of that stream into an array.
int initialCapacity = ( ( codePoints.length / chunkSize ) + 1 );
List < String > strings = new ArrayList <>( initialCapacity );
StringBuilder sb = new StringBuilder();
for ( int i = 0 ; i < codePoints.length ; i++ )
{
sb.appendCodePoint( codePoints[ i ] );
if ( 0 == ( ( i + 1 ) % chunkSize ) ) // Every nth code point.
{
strings.add( sb.toString() ); // Remember this iteration's value.
sb.setLength( 0 ); // Clear the contents of the `StringBuilder` object.
}
}
if ( sb.length() > 0 ) // If partial string leftover, save it too. Or not… just delete this `if` block.
{
strings.add( sb.toString() ); // Remember last iteration's value.
}
System.out.println( "strings = " + strings );
strings = [Theq, uick, brow, nfox, jump, s]
Это работает с нелатинскими символами. Здесь мы заменяем
qс ЛИЦОМ С МЕДИЦИНСКОЙ МАСКОЙ .
String text = "The😷uickbrownfoxjumps"
strings = [The😷, uick, brow, nfox, jump, s]
Решение Java 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;
}
Если вы хотите разделить строку поровну назад, то есть справа налево, например, разделить 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;
}
Самое простое решение:
/**
* Slices string by passed - in slice length.
* If passed - in string is null or slice length less then 0 throws IllegalArgumentException.
* @param toSlice string to slice
* @param sliceLength slice length
* @return List of slices
*/
public static List<String> stringSlicer(String toSlice, int sliceLength) {
if (toSlice == null) {
throw new IllegalArgumentException("Passed - in string is null");
}
if (sliceLength < 0) {
throw new IllegalArgumentException("Slice length can not be less then 0");
}
if (toSlice.isEmpty() || toSlice.length() <= sliceLength) {
return List.of(toSlice);
}
return Arrays.stream(toSlice.split(String.format("(?s)(?<=\\G.{%d})", sliceLength))).collect(Collectors.toList());
}
Вот моя версия, основанная на потоках RegEx и Java 8. Стоит отметить, что Matcher.results() метод доступен начиная с Java 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());
}
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"]
@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);
}
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;
}
Я спросил @Alan Moore в комментарии к принятому решению, как можно обрабатывать строки с символами новой строки. Он предложил использовать 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://stackru.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
*/
}
Но мне также нравится решение @Jon Skeets в /questions/17866623/razbit-stroku-na-podstroki-ravnoj-dlinyi-v-java/17866637#17866637. Для удобства сопровождения в больших проектах, где не все имеют одинаковый опыт работы с регулярными выражениями, я бы, вероятно, использовал решение Jons.
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;
}
Другое решение о грубой силе может быть
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]);
}
Где код просто перебирает строку с подстрокой