Простой способ повторить строку в Java
Я ищу простой метод или оператор, который позволяет мне повторять некоторые строки n раз. Я знаю, что мог бы написать это, используя цикл for, но я хочу избегать циклов for всякий раз, когда это необходимо, и где-то должен существовать простой прямой метод.
String str = "abc";
String repeated = str.repeat(3);
repeated.equals("abcabcabc");
Относится к:
Повторите строку javascript Создайте NSString, повторяя другую строку заданное количество раз
отредактированный
Я стараюсь избегать циклов, когда они не являются полностью необходимыми, потому что:
Они добавляют к числу строк кода, даже если они спрятаны в другой функции.
Кто-то, читающий мой код, должен выяснить, что я делаю в цикле for. Даже если он прокомментирован и имеет значимые имена переменных, они все равно должны убедиться, что он не делает ничего "умного".
Программисты любят помещать умные вещи в циклы, даже если я пишу это для того, чтобы "делать только то, для чего они предназначены", что не исключает возможности появления кого-то и добавления некоторого дополнительного умного "исправления".
Их очень часто легко ошибиться. Для циклов, включающих индексы, склонны генерировать по одной ошибке.
Для циклов часто используются одни и те же переменные, что увеличивает вероятность того, что действительно трудно найти ошибки в области видимости.
Для циклов увеличьте количество мест, которые должен искать охотник за насекомыми.
34 ответа
Начиная с Java 11, есть методString::repeat это именно то, что вы просили:
String str = "abc";
String repeated = str.repeat(3);
repeated.equals("abcabcabc");
Его Javadoc говорит:
/**
* Returns a string whose value is the concatenation of this
* string repeated {@code count} times.
* <p>
* If this string is empty or count is zero then the empty
* string is returned.
*
* @param count number of times to repeat
*
* @return A string composed of this string repeated
* {@code count} times or the empty string if this
* string is empty or count is zero
*
* @throws IllegalArgumentException if the {@code count} is
* negative.
*
* @since 11
*/
Вот самая короткая версия (требуется Java 1.5+):
repeated = new String(new char[n]).replace("\0", s);
куда n сколько раз вы хотите повторить строку и s строка для повторения
Нет импорта или библиотеки не требуется.
Если вы используете Java <= 7, это так просто:
// create a string made up of n copies of string s
String.format("%0" + n + "d", 0).replace("0",s);
В Java 8 и выше есть простой способ:
// create a string made up of n copies of string s
String.join("", Collections.nCopies(n, s));
Java 11 добавил новый repeat(int count) метод специально для этого ( ссылка)
int n = 3;
"abc".repeat(n);
Commons Lang StringUtils.repeat()
Использование:
String str = "abc";
String repeated = StringUtils.repeat(str, 3);
repeated.equals("abcabcabc");
Java 8 String.join обеспечивает аккуратный способ сделать это в сочетании с Collections.nCopies:
// say hello 100 times
System.out.println(String.join("", Collections.nCopies(100, "hello")));
Вот способ сделать это, используя только стандартные функции String и без явных циклов:
// create a string made up of n copies of s
repeated = String.format(String.format("%%%ds", n), " ").replace(" ",s);
Если вы похожи на меня и хотите использовать Google Guava, а не Apache Commons. Вы можете использовать метод repeat в классе Guava Strings.
Strings.repeat("-", 60);
С Java-8, вы также можете использовать Stream.generate,
import static java.util.stream.Collectors.joining;
...
String repeated = Stream.generate(() -> "abc").limit(3).collect(joining()); //"abcabcabc"
и вы можете обернуть его в простой служебный метод, если это необходимо:
public static String repeat(String str, int times) {
return Stream.generate(() -> str).limit(times).collect(joining());
}
Так ты хочешь избежать петель?
Вот оно:
public static String repeat(String s, int times) {
if (times <= 0) return "";
else return s + repeat(s, times-1);
}
(конечно я знаю, что это некрасиво и неэффективно, но у него нет петель:-p)
Вы хотите, чтобы это было проще и красивее? использовать Jython:
s * 3
Изменить: давайте немного оптимизировать это:-D
public static String repeat(String s, int times) {
if (times <= 0) return "";
else if (times % 2 == 0) return repeat(s+s, times/2);
else return s + repeat(s+s, times/2);
}
Edit2: я сделал быстрый и грязный тест для 4 основных альтернатив, но у меня нет времени запустить его несколько раз, чтобы получить средства и построить график для нескольких входов... Так что вот код, если кто-то хочет попробовать это:
public class Repeat {
public static void main(String[] args) {
int n = Integer.parseInt(args[0]);
String s = args[1];
int l = s.length();
long start, end;
start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
if(repeatLog2(s,i).length()!=i*l) throw new RuntimeException();
}
end = System.currentTimeMillis();
System.out.println("RecLog2Concat: " + (end-start) + "ms");
start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
if(repeatR(s,i).length()!=i*l) throw new RuntimeException();
}
end = System.currentTimeMillis();
System.out.println("RecLinConcat: " + (end-start) + "ms");
start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
if(repeatIc(s,i).length()!=i*l) throw new RuntimeException();
}
end = System.currentTimeMillis();
System.out.println("IterConcat: " + (end-start) + "ms");
start = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
if(repeatSb(s,i).length()!=i*l) throw new RuntimeException();
}
end = System.currentTimeMillis();
System.out.println("IterStrB: " + (end-start) + "ms");
}
public static String repeatLog2(String s, int times) {
if (times <= 0) {
return "";
}
else if (times % 2 == 0) {
return repeatLog2(s+s, times/2);
}
else {
return s + repeatLog2(s+s, times/2);
}
}
public static String repeatR(String s, int times) {
if (times <= 0) {
return "";
}
else {
return s + repeatR(s, times-1);
}
}
public static String repeatIc(String s, int times) {
String tmp = "";
for (int i = 0; i < times; i++) {
tmp += s;
}
return tmp;
}
public static String repeatSb(String s, int n) {
final StringBuilder sb = new StringBuilder();
for(int i = 0; i < n; i++) {
sb.append(s);
}
return sb.toString();
}
}
Он принимает 2 аргумента, первый - это число итераций (каждая функция запускается с временем повтора arg от 1..n), а второй - строка для повторения.
Пока что быстрая проверка времени работы с разными входами оставляет ранжирование примерно таким (лучше или хуже):
- Итеративное добавление StringBuilder (1x).
- Рекурсивные конкатенации log2 вызовов (~3x).
- Рекурсивная конкатенация линейных вызовов (~30x).
- Итеративная конкатенация линейная (~45х).
Я бы никогда не догадался, что рекурсивная функция была быстрее, чем for цикл: -о
Веселитесь (Ction XD).
Это содержит меньше символов, чем ваш вопрос
public static String repeat(String s, int n) {
if(s == null) {
return null;
}
final StringBuilder sb = new StringBuilder(s.length() * n);
for(int i = 0; i < n; i++) {
sb.append(s);
}
return sb.toString();
}
Основываясь на ответе Фортрана, это рекурсивная версия, которая использует StringBuilder:
public static void repeat(StringBuilder stringBuilder, String s, int times) {
if (times > 0) {
repeat(stringBuilder.append(s), s, times - 1);
}
}
public static String repeat(String s, int times) {
StringBuilder stringBuilder = new StringBuilder(s.length() * times);
repeat(stringBuilder, s, times);
return stringBuilder.toString();
}
Я хотел функцию для создания списка вопросительных знаков, разделенных запятыми, для целей JDBC, и нашел этот пост. Итак, я решил взять два варианта и посмотреть, какой из них работает лучше. После 1 миллиона итераций садовый сорт StringBuilder занял 2 секунды (fun1), а загадочная, предположительно, более оптимальная версия (fun2) - 30 секунд. Какой смысл снова быть загадочным?
private static String fun1(int size) {
StringBuilder sb = new StringBuilder(size * 2);
for (int i = 0; i < size; i++) {
sb.append(",?");
}
return sb.substring(1);
}
private static String fun2(int size) {
return new String(new char[size]).replaceAll("\0", ",?").substring(1);
}
ООП решение
Почти каждый ответ предлагает статическую функцию в качестве решения, но, думая об объектно-ориентированном (для целей повторного использования и ясности), я придумал решение через делегирование через интерфейс CharSequence (который также открывает удобство использования на изменяемых классах CharSequence-Classes).
Следующий класс может использоваться с или без Separator-String/CharSequence, и каждый вызов toString() создает последнюю повторяемую строку. Input/Separator не только ограничен String-Class, но может быть любым классом, который реализует CharSequence (например, StringBuilder, StringBuffer и т. Д.)!
Исходный код:
/**
* Helper-Class for Repeating Strings and other CharSequence-Implementations
* @author Maciej Schuttkowski
*/
public class RepeatingCharSequence implements CharSequence {
final int count;
CharSequence internalCharSeq = "";
CharSequence separator = "";
/**
* CONSTRUCTOR - RepeatingCharSequence
* @param input CharSequence to repeat
* @param count Repeat-Count
*/
public RepeatingCharSequence(CharSequence input, int count) {
if(count < 0)
throw new IllegalArgumentException("Can not repeat String \""+input+"\" less than 0 times! count="+count);
if(count > 0)
internalCharSeq = input;
this.count = count;
}
/**
* CONSTRUCTOR - Strings.RepeatingCharSequence
* @param input CharSequence to repeat
* @param count Repeat-Count
* @param separator Separator-Sequence to use
*/
public RepeatingCharSequence(CharSequence input, int count, CharSequence separator) {
this(input, count);
this.separator = separator;
}
@Override
public CharSequence subSequence(int start, int end) {
checkBounds(start);
checkBounds(end);
int subLen = end - start;
if (subLen < 0) {
throw new IndexOutOfBoundsException("Illegal subSequence-Length: "+subLen);
}
return (start == 0 && end == length()) ? this
: toString().substring(start, subLen);
}
@Override
public int length() {
//We return the total length of our CharSequences with the separator 1 time less than amount of repeats:
return count < 1 ? 0
: ( (internalCharSeq.length()*count) + (separator.length()*(count-1)));
}
@Override
public char charAt(int index) {
final int internalIndex = internalIndex(index);
//Delegate to Separator-CharSequence or Input-CharSequence depending on internal index:
if(internalIndex > internalCharSeq.length()-1) {
return separator.charAt(internalIndex-internalCharSeq.length());
}
return internalCharSeq.charAt(internalIndex);
}
@Override
public String toString() {
return count < 1 ? ""
: new StringBuilder(this).toString();
}
private void checkBounds(int index) {
if(index < 0 || index >= length())
throw new IndexOutOfBoundsException("Index out of Bounds: "+index);
}
private int internalIndex(int index) {
// We need to add 1 Separator-Length to total length before dividing,
// as we subtracted one Separator-Length in "length()"
return index % ((length()+separator.length())/count);
}
}
Использование-Пример:
public static void main(String[] args) {
//String input = "12345";
//StringBuffer input = new StringBuffer("12345");
StringBuilder input = new StringBuilder("123");
//String separator = "<=>";
StringBuilder separator = new StringBuilder("<=");//.append('>');
int repeatCount = 2;
CharSequence repSeq = new RepeatingCharSequence(input, repeatCount, separator);
String repStr = repSeq.toString();
System.out.println("Repeat="+repeatCount+"\tSeparator="+separator+"\tInput="+input+"\tLength="+input.length());
System.out.println("CharSeq:\tLength="+repSeq.length()+"\tVal="+repSeq);
System.out.println("String :\tLength="+repStr.length()+"\tVal="+repStr);
//Here comes the Magic with a StringBuilder as Input, as you can append to the String-Builder
//and at the same Time your Repeating-Sequence's toString()-Method returns the updated String :)
input.append("ff");
System.out.println(repSeq);
//Same can be done with the Separator:
separator.append("===").append('>');
System.out.println(repSeq);
}
Пример-выход:
Repeat=2 Separator=<= Input=123 Length=3
CharSeq: Length=8 Val=123<=123
String : Length=8 Val=123<=123
123ff<=123ff
123ff<====>123ff
Использовать Dollar просто:
@Test
public void repeatString() {
String string = "abc";
assertThat($(string).repeat(3).toString(), is("abcabcabc"));
}
PS: повтор работает также для массива, списка, набора и т. Д.
Не самый короткий, но (я думаю) самый быстрый способ - использовать StringBuilder:
/**
* Repeat a String as many times you need.
*
* @param i - Number of Repeating the String.
* @param s - The String wich you want repeated.
* @return The string n - times.
*/
public static String repeate(int i, String s) {
StringBuilder sb = new StringBuilder();
for (int j = 0; j < i; j++)
sb.append(s);
return sb.toString();
}
Используя только классы JRE ( System.arraycopy) и пытаясь минимизировать количество временных объектов, вы можете написать что-то вроде:
public static String repeat(String toRepeat, int times) {
if (toRepeat == null) {
toRepeat = "";
}
if (times < 0) {
times = 0;
}
final int length = toRepeat.length();
final int total = length * times;
final char[] src = toRepeat.toCharArray();
char[] dst = new char[total];
for (int i = 0; i < total; i += length) {
System.arraycopy(src, 0, dst, i, length);
}
return String.copyValueOf(dst);
}
РЕДАКТИРОВАТЬ
и без петель вы можете попробовать с:
public static String repeat2(String toRepeat, int times) {
if (toRepeat == null) {
toRepeat = "";
}
if (times < 0) {
times = 0;
}
String[] copies = new String[times];
Arrays.fill(copies, toRepeat);
return Arrays.toString(copies).
replace("[", "").
replace("]", "").
replaceAll(", ", "");
}
РЕДАКТИРОВАТЬ 2
использование коллекций еще короче:
public static String repeat3(String toRepeat, int times) {
return Collections.nCopies(times, toRepeat).
toString().
replace("[", "").
replace("]", "").
replaceAll(", ", "");
}
Однако мне все еще нравится первая версия.
простое однострочное решение:
требуется Java 8
Collections.nCopies( 3, "abc" ).stream().collect( Collectors.joining() );
Если вам важна скорость, вы должны использовать как можно меньше памяти. Таким образом, требуется работать с массивами символов.
public static String repeatString(String what, int howmany) {
char[] pattern = what.toCharArray();
char[] res = new char[howmany * pattern.length];
int length = pattern.length;
for (int i = 0; i < howmany; i++)
System.arraycopy(pattern, 0, res, i * length, length);
return new String(res);
}
Чтобы проверить скорость, подобный оптимальный метод с использованием StirngBuilder выглядит следующим образом:
public static String repeatStringSB(String what, int howmany) {
StringBuilder out = new StringBuilder(what.length() * howmany);
for (int i = 0; i < howmany; i++)
out.append(what);
return out.toString();
}
и код для проверки:
public static void main(String... args) {
String res;
long time;
for (int j = 0; j < 1000; j++) {
res = repeatString("123", 100000);
res = repeatStringSB("123", 100000);
}
time = System.nanoTime();
res = repeatString("123", 1000000);
time = System.nanoTime() - time;
System.out.println("elapsed repeatString: " + time);
time = System.nanoTime();
res = repeatStringSB("123", 1000000);
time = System.nanoTime() - time;
System.out.println("elapsed repeatStringSB: " + time);
}
И вот результаты запуска из моей системы:
elapsed repeatString: 6006571
elapsed repeatStringSB: 9064937
Обратите внимание, что тест для цикла состоит в том, чтобы запустить JIT и иметь оптимальные результаты.
Для удобства чтения и переносимости:
public String repeat(String str, int count){
if(count <= 0) {return "";}
return new String(new char[count]).replace("\0", str);
}
Если вы беспокоитесь о производительности, просто используйте StringBuilder внутри цикла и выполните.toString() при выходе из цикла. Черт возьми, напиши свой собственный класс Util и используй его снова. 5 строк кода макс.
Простой цикл
public static String repeat(String string, int times) {
StringBuilder out = new StringBuilder();
while (times-- > 0) {
out.append(string);
}
return out.toString();
}
Видя ряд ответов, связанных со StringBuilder, я считаю, что стоит также упомянуть, что есть новыеStringBuilder.repeatиStringBuffer.repeatметоды, добавленные в Java 21 для упрощения добавления нескольких копий символов или строк :
System.out.println(new StringBuilder().repeat('A', 10)); // AAAAAAAAAA
System.out.println(new StringBuilder().repeat("A1", 2)); // A1A1
Если вам известна только длина выходной строки (и она может не делиться на длину входной строки), используйте этот метод:
static String repeat(String s, int length) {
return s.length() >= length ? s.substring(0, length) : repeat(s + s, length);
}
Демонстрация использования:
for (int i = 0; i < 50; i++)
System.out.println(repeat("_/‾\\", i));
Не используйте с пустым s а также length > 0, так как в этом случае невозможно получить желаемый результат.
public static String repeat(String str, int times) {
int length = str.length();
int size = length * times;
char[] c = new char[size];
for (int i = 0; i < size; i++) {
c[i] = str.charAt(i % length);
}
return new String(c);
}
Используя рекурсию, вы можете сделать следующее (используя троичные операторы, максимум одна строка):
public static final String repeat(String string, long number) {
return number == 1 ? string : (number % 2 == 0 ? repeat(string + string, number / 2) : string + repeat(string + string, (number - 1) / 2));
}
Я знаю, это уродливо и, вероятно, не эффективно, но это одна строка!
Попробуйте это:
public static char[] myABCs = {'a', 'b', 'c'};
public static int numInput;
static Scanner in = new Scanner(System.in);
public static void main(String[] args) {
System.out.print("Enter Number of Times to repeat: ");
numInput = in.nextInt();
repeatArray(numInput);
}
public static int repeatArray(int y) {
for (int a = 0; a < y; a++) {
for (int b = 0; b < myABCs.length; b++) {
System.out.print(myABCs[b]);
}
System.out.print(" ");
}
return y;
}
Мне очень нравится этот вопрос. Здесь много знаний и стилей. Так что я не могу оставить это без шоу моего рок-н-ролла;)
{
String string = repeat("1234567890", 4);
System.out.println(string);
System.out.println("=======");
repeatWithoutCopySample(string, 100000);
System.out.println(string);// This take time, try it without printing
System.out.println(string.length());
}
/**
* The core of the task.
*/
@SuppressWarnings("AssignmentToMethodParameter")
public static char[] repeat(char[] sample, int times) {
char[] r = new char[sample.length * times];
while (--times > -1) {
System.arraycopy(sample, 0, r, times * sample.length, sample.length);
}
return r;
}
/**
* Java classic style.
*/
public static String repeat(String sample, int times) {
return new String(repeat(sample.toCharArray(), times));
}
/**
* Java extreme memory style.
*/
@SuppressWarnings("UseSpecificCatch")
public static void repeatWithoutCopySample(String sample, int times) {
try {
Field valueStringField = String.class.getDeclaredField("value");
valueStringField.setAccessible(true);
valueStringField.set(sample, repeat((char[]) valueStringField.get(sample), times));
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
Вам это нравится?
Несмотря на ваше желание не использовать циклы, я думаю, что вы должны использовать цикл.
String repeatString(String s, int repetitions)
{
if(repetitions < 0) throw SomeException();
else if(s == null) return null;
StringBuilder stringBuilder = new StringBuilder(s.length() * repetitions);
for(int i = 0; i < repetitions; i++)
stringBuilder.append(s);
return stringBuilder.toString();
}
Ваши причины не использовать цикл for не очень хорошие. В ответ на вашу критику:
- Какое бы решение вы ни использовали, оно почти наверняка будет длиннее. Использование предварительно встроенной функции позволяет скрыть ее только под несколькими крышками.
- Кто-то, читающий ваш код, должен понять, что вы делаете в этом цикле. Учитывая, что цикл for является идиоматическим способом сделать это, было бы намного легче понять, если бы вы сделали это с помощью цикла for.
- Да, кто-то может добавить что-то умное, но, избегая цикла for, вы делаете что-то умное. Это все равно, что умышленно выстрелить себе в ногу, чтобы случайно не выстрелить себе в ногу.
- Одиночные ошибки также легко понять с помощью одного теста. Принимая во внимание, что вы должны тестировать свой код, легко исправить и поймать ошибку "один за другим". И это стоит отметить: приведенный выше код не содержит ошибки "один за другим". Для петель одинаково легко получить права.
- Так что не используйте переменные повторно. Это не ошибка цикла.
- Опять же, как и любое решение, которое вы используете. И, как я уже отмечал ранее; охотник за ошибками, вероятно, будет ожидать, что вы сделаете это с циклом for, поэтому им будет легче найти его, если вы используете цикл for.
Вот последняя версия Stringutils.java StringUtils.java
public static String repeat(String str, int repeat) {
// Performance tuned for 2.0 (JDK1.4)
if (str == null) {
return null;
}
if (repeat <= 0) {
return EMPTY;
}
int inputLength = str.length();
if (repeat == 1 || inputLength == 0) {
return str;
}
if (inputLength == 1 && repeat <= PAD_LIMIT) {
return repeat(str.charAt(0), repeat);
}
int outputLength = inputLength * repeat;
switch (inputLength) {
case 1 :
return repeat(str.charAt(0), repeat);
case 2 :
char ch0 = str.charAt(0);
char ch1 = str.charAt(1);
char[] output2 = new char[outputLength];
for (int i = repeat * 2 - 2; i >= 0; i--, i--) {
output2[i] = ch0;
output2[i + 1] = ch1;
}
return new String(output2);
default :
StringBuilder buf = new StringBuilder(outputLength);
for (int i = 0; i < repeat; i++) {
buf.append(str);
}
return buf.toString();
}
}
он даже не должен быть таким большим, может быть превращен в него, и может быть скопирован и вставлен в служебный класс в вашем проекте.
public static String repeat(String str, int num) {
int len = num * str.length();
StringBuilder sb = new StringBuilder(len);
for (int i = 0; i < times; i++) {
sb.append(str);
}
return sb.toString();
}
Итак, e5, я думаю, что лучший способ сделать это - просто использовать вышеупомянутый код или любой из ответов здесь. но Commons Lang слишком велик, если это маленький проект
Я создал рекурсивный метод, который делает то же самое, что вы хотите.. не стесняйтесь использовать это...
public String repeat(String str, int count) {
return count > 0 ? repeat(str, count -1) + str: "";
}
У меня есть тот же ответ на Могу ли я умножить строки в Java, чтобы повторить последовательности?