Ik heb zoiets als het volgende:
int i = 3;
String someNum = "123";
Ik zou graag willen toevoegen i“0” S tot de someNumString. Heeft het op een of andere manier om een tekenreeks te vermenigvuldigen om het als Python te herhalen?
Dus ik kon gewoon gaan:
someNum = sumNum + ("0" * 3);
of iets dergelijks?
Waar, in dit geval, mijn eindresultaat zou zijn:
“123000”.
Antwoord 1, Autoriteit 100%
De eenvoudigste manier in duidelijke Java zonder afhankelijkheden is de volgende one-liner:
new String(new char[generation]).replace("\0", "-")
Vervang Generation met het aantal herhalingen en de “-” met de string (of char) die u wilt herhaald.
Dit alles is een lege reeks die N Aantal 0x00-tekens bevat, en de ingebouwde string # Vervangende methode doet de rest.
Hier is een monster om te kopiëren en te plakken:
public static String repeat(int count, String with) {
return new String(new char[count]).replace("\0", with);
}
public static String repeat(int count) {
return repeat(count, " ");
}
public static void main(String[] args) {
for (int n = 0; n < 10; n++) {
System.out.println(repeat(n) + " Hello");
}
for (int n = 0; n < 10; n++) {
System.out.println(repeat(n, ":-) ") + " Hello");
}
}
Antwoord 2, Autoriteit 39%
Nee, maar je kunt in Scala! (En compileer dat en voer het uit met behulp van een Java-implementatie !!!!)
Als je het nu op de makkelijke manier in Java wilt doen, gebruik dan het Apache commons-lang pakket. Ervan uitgaande dat je maven gebruikt, voeg je deze afhankelijkheid toe aan je pom.xml:
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.4</version>
</dependency>
En gebruik dan StringUtils.repeat als volgt:
import org.apache.commons.lang.StringUtils
...
someNum = sumNum + StringUtils.repeat("0", 3);
Antwoord 3, autoriteit 27%
Google Guavabiedt een andere manier om dit te doen met Strings#repeat():
String repeated = Strings.repeat("pete and re", 42);
Antwoord 4, autoriteit 21%
Twee manieren komen bij me op:
int i = 3;
String someNum = "123";
// Way 1:
char[] zeroes1 = new char[i];
Arrays.fill(zeroes1, '0');
String newNum1 = someNum + new String(zeroes1);
System.out.println(newNum1); // 123000
// Way 2:
String zeroes2 = String.format("%0" + i + "d", 0);
String newNum2 = someNum + zeroes2;
System.out.println(newNum2); // 123000
Manier 2 kan worden ingekort tot:
someNum += String.format("%0" + i + "d", 0);
System.out.println(someNum); // 123000
Meer over String#format()is beschikbaar in zijn API-documenten dat van java.util.Formatter.
Antwoord 5, autoriteit 20%
String::repeat
Gebruik String::repeatin Java 11 en hoger.
Voorbeelden
"A".repeat( 3 )
AAA
En het voorbeeld uit de vraag.
int i = 3; //frequency to repeat
String someNum = "123"; // initial string
String ch = "0"; // character to append
someNum = someNum + ch.repeat(i); // formulation of the string
System.out.println(someNum); // would result in output -- "123000"
Antwoord 6, autoriteit 19%
Als je losse karakters herhaalt, zoals de OP, en het maximum aantal herhalingen niet te hoog is, dan zou je een simpele substring-operatie als deze kunnen gebruiken:
int i = 3;
String someNum = "123";
someNum += "00000000000000000000".substring(0, i);
Antwoord 7, autoriteit 13%
Nee. Java heeft deze functie niet. U moet uw String maken met een StringBuilder , en een soort lus.
Antwoord 8, autoriteit 10%
Een eenvoudige manier om dit te doen.
private String repeatString(String s,int count){
StringBuilder r = new StringBuilder();
for (int i = 0; i < count; i++) {
r.append(s);
}
return r.toString();
}
Antwoord 9, autoriteit 10%
Java 8 biedt een manier (zij het een beetje onhandig). Als methode:
public static String repeat(String s, int n) {
return Stream.generate(() -> s).limit(n).collect(Collectors.joining(""));
}
of minder efficiënt, maar mooier IMHO:
public static String repeat(String s, int n) {
return Stream.generate(() -> s).limit(n).reduce((a, b) -> a + b);
}
Antwoord 10, autoriteit 9%
Ik heb een methode gemaakt die hetzelfde doet als jij wilt, probeer dit gerust:
public String repeat(String s, int count) {
return count > 0 ? s + repeat(s, --count) : "";
}
Antwoord 11, autoriteit 5%
met Dollar:
String s = "123" + $("0").repeat(3); // 123000
Antwoord 12, autoriteit 4%
Ik geloof niet dat Java deze functie standaard biedt, hoewel het wel leuk zou zijn. Ik schrijf af en toe Perl-code en de operator xin Perl is erg handig voor het herhalen van strings!
Echter StringUtilsIn commons-langbiedt deze functie. De methode wordt repeat()genoemd. Uw enige andere optie is om het handmatig te bouwen met behulp van een lus.
Antwoord 13, Autoriteit 4%
met guava :
Joiner.on("").join(Collections.nCopies(i, someNum));
Antwoord 14, Autoriteit 2%
Nee, dat kan niet. U kunt deze functie echter gebruiken om een teken te herhalen.
public String repeat(char c, int times){
StringBuffer b = new StringBuffer();
for(int i=0;i < times;i++){
b.append(c);
}
return b.toString();
}
Disclaimer: Ik heb het hier getypt. Kan fouten hebben.
Antwoord 15
Een generalisatie van het antwoord van Dave Hartnoll (ik neem het concept ad aburdum voornamelijk, misschien gebruik dat niet in iets waar je snelheid nodig hebt).
Hierdoor kan iemand de reeks vullen met I-tekens na een bepaald patroon.
int i = 3;
String someNum = "123";
String pattern = "789";
someNum += "00000000000000000000".replaceAll("0",pattern).substring(0, i);
Als u geen patroon nodig heeft, maar gewoon een enkel teken dat u kunt gebruiken (het is een beetje sneller):
int i = 3;
String someNum = "123";
char c = "7";
someNum += "00000000000000000000".replaceAll("0",c).substring(0, i);
Antwoord 16
vergelijkbaar met wat al is gezegd:
public String multStuff(String first, String toAdd, int amount) {
String append = "";
for (int i = 1; i <= amount; i++) {
append += toAdd;
}
return first + append;
}
Invoer multStuff("123", "0", 3);
Uitgang "123000"
Antwoord 17
We kunnen vermenigvuldigingen maken met * in Python, maar niet in Java kunt u gebruiken voor lus in uw geval:
String sample="123";
for(int i=0;i<3;i++)
{
sample=+"0";
}
Antwoord 18
Er is geen snelkoppeling om dit in Java te doen zoals het voorbeeld dat je hebt gegeven in Python.
u hoeft dit te doen:
for (;i > 0; i--) {
somenum = somenum + "0";
}
Antwoord 19
De eenvoudigste manier is:
String someNum = "123000";
System.out.println(someNum);