Vreau să se alăture o String[]
cu un adeziv șir. Există o funcție pentru asta?
Incepand de la Java8 este posibil să se utilizeze Șir de caractere.join()
.
String.join(", ", new String[]{"Hello", "World", "!"})
Generează:
Hello, World, !
În caz contrar, Apache Commons Lang are StringUtils
clasă care are o join
funcția care se va alătura tablouri împreună pentru a face un "String".
De exemplu:
StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")
Generează următoarele String
:
Hello, World, !
În Java 8, puteți utiliza
String[] a = new String[] {"a", "b", "c"};
String result = Arrays.stream(a).collect(Collectors.joining(", "));
nou Șir de caractere.alăturați-vă metodă: https://stackoverflow.com/a/21756398/466677
java.util.StringJoiner clasa: http://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html
Ai putea scrie cu ușurință o astfel de funcție în aproximativ zece linii de cod:
String combine(String[] s, String glue)
{
int k = s.length;
if ( k == 0 )
{
return null;
}
StringBuilder out = new StringBuilder();
out.append( s[0] );
for ( int x=1; x < k; ++x )
{
out.append(glue).append(s[x]);
}
return out.toString();
}
Un pic de mod în loc de a folosi subșir():
//join(String array,delimiter)
public static String join(String r[],String d)
{
if (r.length == 0) return "";
StringBuilder sb = new StringBuilder();
int i;
for(i=0;i<r.length-1;i++){
sb.append(r[i]);
sb.append(d);
}
sb.append(r[i]);
return sb.toString();
}
Ca și cu multe întrebări în ultima vreme, Java 8 la salvare:
Java 8 a adăugat o nouă metodă statică a java.lang.String
care face exact ceea ce vrei:
public static String join(CharSequence delimeter, CharSequence... elements);
Folosind-o:
String s = String.join(", ", new String[] {"Hello", "World", "!"});
Rezultate în:
"Hello, World, !"
Google guava's library, de asemenea, a acest tip de capacitate. Puteți vedea String[] de exemplu, de asemenea, de la API.
Cum este deja descris în api, feriți-vă de imutabilitatea de constructor metode.
Se poate accepta o serie de obiecte așa că'll funcționează în cazul tău. În experiența mea anterioară, am încercat aderarea la o Stivă, care este un iterable și funcționează bine.
Proba la mine :
Deque<String> nameStack = new ArrayDeque<>();
nameStack.push("a coder");
nameStack.push("i am");
System.out.println("|" + Joiner.on(' ').skipNulls().join(nameStack) + "|");
afiseaza : |eu sunt un programator|
Dacă utilizați Cadru de Primăvară apoi StringUtils clasă:
import static org.springframework.util.StringUtils.arrayToDelimitedString;
arrayToDelimitedString(new String[] {"A", "B", "C"}, "\n");
Având în vedere:
String[] a = new String[] { "Hello", "World", "!" };
Apoi, ca o alternativă la coobird's a răspunde, în cazul în care adezivul este ", ":
Arrays.asList(a).toString().replaceAll("^\\[|\\]$", "")
Sau să înlănțui cu un alt șir de caractere, cum ar fi " & ".
Arrays.asList(a).toString().replaceAll(", ", " & ").replaceAll("^\\[|\\]$", "")
Cu toate acestea... aceasta funcționează NUMAI dacă știți că valorile din matrice sau lista NU conține șirul de caractere ", ".
Nu în miez, nr. O căutare pentru "java matrice se alăture șir lipici" vă va oferi câteva fragmente de cod cu privire la modul de a realiza acest lucru, deși.
de exemplu
public static String join(Collection s, String delimiter) {
StringBuffer buffer = new StringBuffer();
Iterator iter = s.iterator();
while (iter.hasNext()) {
buffer.append(iter.next());
if (iter.hasNext()) {
buffer.append(delimiter);
}
}
return buffer.toString();
}
Daca'am aterizat aici în căutarea pentru o rapidă matrice-să-șir de conversie, încerca Tablouri.toString().
Creează un Șir de reprezentare de Obiect[]
trecut. Rezultatul este înconjurat de paranteze (
"[]"), fiecare element este convertit la un Șir prin
Șir de caractere.valueOf(Obiect) și separate prin", "
. Dacă matricea estenul", apoi " "nul"
este returnat.
Doar pentru "am'am cea mai scurtă" provocare, aici sunt la mine ;)
Iterativ:
public static String join(String s, Object... a) {
StringBuilder o = new StringBuilder();
for (Iterator<Object> i = Arrays.asList(a).iterator(); i.hasNext();)
o.append(i.next()).append(i.hasNext() ? s : "");
return o.toString();
}
Recursiv:
public static String join(String s, Object... a) {
return a.length == 0 ? "" : a[0] + (a.length == 1 ? "" : s + join(s, Arrays.copyOfRange(a, 1, a.length)));
}
Nimic nu built-in de care să știu.
Apache Commons Lang are o clasa numita StringUtils
care conține multe se alăture funcții.
Acest lucru este cum am face-o.
private String join(String[] input, String delimiter)
{
StringBuilder sb = new StringBuilder();
for(String value : input)
{
sb.append(value);
sb.append(delimiter);
}
int length = sb.length();
if(length > 0)
{
// Remove the extra delimiter
sb.setLength(length - delimiter.length());
}
return sb.toString();
}
O alternativă similară
/**
* @param delimiter
* @param inStr
* @return String
*/
public static String join(String delimiter, String... inStr)
{
StringBuilder sb = new StringBuilder();
if (inStr.length > 0)
{
sb.append(inStr[0]);
for (int i = 1; i < inStr.length; i++)
{
sb.append(delimiter);
sb.append(inStr[i]);
}
}
return sb.toString();
}
Mea de spin.
public static String join(Object[] objects, String delimiter) {
if (objects.length == 0) {
return "";
}
int capacityGuess = (objects.length * objects[0].toString().length())
+ ((objects.length - 1) * delimiter.length());
StringBuilder ret = new StringBuilder(capacityGuess);
ret.append(objects[0]);
for (int i = 1; i < objects.length; i++) {
ret.append(delimiter);
ret.append(objects[i]);
}
return ret.toString();
}
public static String join(Object... objects) {
return join(objects, "");
}
Îți place meu de 3 linii de cale folosind doar clasa String's metode?
static String join(String glue, String[] array) {
String line = "";
for (String s : array) line += s + glue;
return (array.length == 0) ? line : line.substring(0, line.length() - glue.length());
}
În cazul în care te're folosind Funcționale Java library, și pentru un motiv oarecare poate't folosi Fluxuri de Java 8 (care ar putea fi cazul atunci când se utilizează Android + Retrolambda plugin), aici este o soluție funcțională pentru tine:
String joinWithSeparator(List<String> items, String separator) {
return items
.bind(id -> list(separator, id))
.drop(1)
.foldLeft(
(result, item) -> result + item,
""
);
}
Rețineți că l's nu mai eficientă abordare, dar aceasta nu funcționează bine pentru liste mici.
Eu fac acest fel, folosind un StringBuilder:
public static String join(String[] source, String delimiter) {
if ((null == source) || (source.length < 1)) {
return "";
}
StringBuilder stringbuilder = new StringBuilder();
for (String s : source) {
stringbuilder.append(s + delimiter);
}
return stringbuilder.toString();
} // join((String[], String)