son - separar una palabra en letras java

Java: convierte la lista<String> en una cadena

Question

JavaScript tiene Array.join()

js>["Bill","Bob","Steve"].join(" and ")
Bill and Bob and Steve

¿Tiene Java algo como esto? Sé que puedo improvisar algo con StringBuilder:

static public String join(List<String> list, String conjunction)
{
   StringBuilder sb = new StringBuilder();
   boolean first = true;
   for (String item : list)
   {
      if (first)
         first = false;
      else
         sb.append(conjunction);
      sb.append(item);
   }
   return sb.toString();
}

... pero no tiene sentido hacer esto si algo así ya forma parte del JDK.

Answer 1

Solución de Java 8 con java.util.StringJoiner

Java 8 tiene una clase de StringJoiner . Pero aún necesitas escribir un poco de repetitivo, porque es Java.

StringJoiner sj = new StringJoiner(" and ", "" , "");
String[] names = {"Bill", "Bob", "Steve"};
for (String name : names) {
   sj.add(name);
}
System.out.println(sj);

Answer 2

Con Java 8 puede hacer esto sin ninguna biblioteca de terceros.

Si desea unirse a una colección de cadenas, puede usar el nuevo método String.join() :

List<String> list = Arrays.asList("foo", "bar", "baz");
String joined = String.join(" and ", list); // "foo and bar and baz"

Si tiene una Colección con otro tipo que no sea String, puede usar la API Stream con el recopilador que se une :

List<Person> list = Arrays.asList(
  new Person("John", "Smith"),
  new Person("Anna", "Martinez"),
  new Person("Paul", "Watson ")
);

String joinedFirstNames = list.stream()
  .map(Person::getFirstName)
  .collect(Collectors.joining(", ")); // "John, Anna, Paul"

La clase StringJoiner también puede ser útil.

Answer 3

Con java 1.8 se puede usar stream,

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
List<String> list = Arrays.asList("Bill","Bob","Steve").
String str = list.stream().collect(Collectors.joining(" and "));

Answer 4

Con un colector java 8, esto se puede hacer con el siguiente código:

Arrays.asList("Bill", "Bob", "Steve").stream()
.collect(Collectors.joining(" and "));

Además, la solución más sencilla en java 8:

String.join(" and ", "Bill", "Bob", "Steve");

o

String.join(" and ", Arrays.asList("Bill", "Bob", "Steve"));

Answer 5

El código que tiene es la forma correcta de hacerlo si desea utilizar JDK sin bibliotecas externas. No hay un simple "one-liner" que puedas usar en JDK.

Si puede usar librerías externas, le recomiendo que busque en la clase org.apache.commons.lang.StringUtils en la biblioteca de Apache Commons.

Un ejemplo de uso:

List<String> list = Arrays.asList("Bill", "Bob", "Steve");
String joinedResult = StringUtils.join(list, " and ");

Answer 6

En Android puedes usar la clase TextUtils .

TextUtils.join(" and ", names);

Answer 7

Es posible que desee probar el método de unión StringUtils de Apache Commons:

http://commons.apache.org/lang/api/org/apache/commons/lang/StringUtils.html#join(java.util.Iterator , java.lang.String)

Descubrí que Apache StringUtils recupera la holgura de jdk ;-)

Answer 8

Escribí este (lo uso para beans y toString , así que no escriba Collection<String> ):

public static String join(Collection<?> col, String delim) {
    StringBuilder sb = new StringBuilder();
    Iterator<?> iter = col.iterator();
    if (iter.hasNext())
        sb.append(iter.next().toString());
    while (iter.hasNext()) {
        sb.append(delim);
        sb.append(iter.next().toString());
    }
    return sb.toString();
}

pero la Collection no es compatible con JSP, por lo que para TLD escribí:

public static String join(List<?> list, String delim) {
    int len = list.size();
    if (len == 0)
        return "";
    StringBuilder sb = new StringBuilder(list.get(0).toString());
    for (int i = 1; i < len; i++) {
        sb.append(delim);
        sb.append(list.get(i).toString());
    }
    return sb.toString();
}

y poner en archivo .tld :

<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.1" xmlns="http://java.sun.com/xml/ns/javaee"
    <function>
        <name>join</name>
        <function-class>com.core.util.ReportUtil</function-class>
        <function-signature>java.lang.String join(java.util.List, java.lang.String)</function-signature>
    </function>
</taglib>

y usarlo en archivos JSP como:

<%@taglib prefix="funnyFmt" uri="tag:com.core.util,2013:funnyFmt"%>
${funnyFmt:join(books, ", ")}

Answer 9

Java 8 trae el

Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

método, que es nullsafe utilizando prefix + suffix para valores nulos.

Se puede utilizar de la siguiente manera:

String s = stringList.stream().collect(Collectors.joining(" and ", "prefix_", "_suffix"))

El método Collectors.joining(CharSequence delimiter) simplemente llama a joining(delimiter, "", "") internamente.

Answer 10

La API de Guava de Google también tiene .join (), aunque (como debería ser obvio con las otras respuestas), Apache Commons es prácticamente el estándar aquí.

Answer 11

No fuera de la caja, pero muchas bibliotecas tienen similares:

Commons Lang:

org.apache.commons.lang.StringUtils.join(list, conjunction);

Primavera:

org.springframework.util.StringUtils.collectionToDelimitedString(list, conjunction);

Answer 12

No, no hay tal método de conveniencia en la API estándar de Java.

No es sorprendente que Apache Commons proporcione tal cosa en su clase de StringUtils en caso de que no quiera escribirlo usted mismo.

Answer 13

Prueba esto:

java.util.Arrays.toString(anArray).replaceAll(", ", ",")
                .replaceFirst("^//[","").replaceFirst("//]$","");

Answer 14

Puede usar la biblioteca de apache commons que tiene una clase StringUtils y un método de unión.

Consulte este enlace: https://commons.apache.org/proper/commons-lang/javadocs/api.2.0/org/apache/commons/lang/StringUtils.html

Tenga en cuenta que el enlace anterior puede volverse obsoleto con el tiempo, en cuyo caso simplemente puede buscar en "apache commons StringUtils", lo que le permitirá encontrar la última referencia.

(referenciado desde este hilo) equivalentes de Java de C # String.Format () y String.Join ()

Answer 15

Puedes hacerlo:

String aToString = java.util.Arrays.toString(anArray);
// Do not need to do this if you are OK with ''['' and '']''
aToString = aToString.substring(1, aToString.length() - 1);

O una sola línea (solo cuando no quieres ''['' y '']'')

String aToString = java.util.Arrays.toString(anArray).substring(1).replaceAll("//]$", "");

Espero que esto ayude.

Answer 16

Puedes usar esto desde los StringUtils de Spring Framework. Sé que ya se ha mencionado, pero en realidad puedes tomar este código y funciona de inmediato, sin necesidad de Spring para ello.

// from https://github.com/spring-projects/spring-framework/blob/master/spring-core/src/main/java/org/springframework/util/StringUtils.java

/*
 * Copyright 2002-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
public class StringUtils {
    public static String collectionToDelimitedString(Collection<?> coll, String delim, String prefix, String suffix) {
        if(coll == null || coll.isEmpty()) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        Iterator<?> it = coll.iterator();
        while (it.hasNext()) {
            sb.append(prefix).append(it.next()).append(suffix);
            if (it.hasNext()) {
                sb.append(delim);
            }
        }
        return sb.toString();
    }
}

Answer 17

Si está utilizando Eclipse Collections (anteriormente GS Collections ), puede usar el método makeString() .

List<String> list = Arrays.asList("Bill", "Bob", "Steve");

String string = ListAdapter.adapt(list).makeString(" and ");

Assert.assertEquals("Bill and Bob and Steve", string);

Si puede convertir su List a un tipo de Colecciones Eclipse, entonces puede deshacerse del adaptador.

MutableList<String> list = Lists.mutable.with("Bill", "Bob", "Steve");
String string = list.makeString(" and ");

Si solo quieres una cadena separada por comas, puedes usar la versión de makeString() que no tiene parámetros.

Assert.assertEquals(
    "Bill, Bob, Steve", 
    Lists.mutable.with("Bill", "Bob", "Steve").makeString());

Nota: Soy un comendador de Eclipse Collections.

Answer 18

Todas las referencias a Apache Commons están bien (y eso es lo que la mayoría de la gente usa), pero creo que el equivalente de Guava , Joiner , tiene una API mucho más agradable.

Usted puede hacer el caso de unirse simple con

Joiner.on(" and ").join(names)

pero también tratar fácilmente con nulos:

Joiner.on(" and ").skipNulls().join(names);

o

Joiner.on(" and ").useForNull("[unknown]").join(names);

y (lo suficientemente útil en lo que a mí respecta para usarlo con preferencia a commons-lang), la capacidad de tratar con Mapas:

Map<String, Integer> ages = .....;
String foo = Joiner.on(", ").withKeyValueSeparator(" is ").join(ages);
// Outputs:
// Bill is 25, Joe is 30, Betty is 35

que es extremadamente útil para la depuración, etc.

Answer 19

Tres posibilidades en Java 8:

List<String> list = Arrays.asList("Alice", "Bob", "Charlie")

String result = String.join(" and ", list);

result = list.stream().collect(Collectors.joining(" and "));

result = list.stream().reduce((t, u) -> t + " and " + u).orElse("");

Answer 20

Una forma divertida de hacerlo con JDK puro, en una línea de servicio:

String[] array = new String[] { "Bill", "Bob", "Steve","[Bill]","1,2,3","Apple ][" };
String join = " and ";

String joined = Arrays.toString(array).replaceAll(", ", join)
        .replaceAll("(^//[)|(//]$)", "");

System.out.println(joined);

Salida:

Bill y Bob y Steve y [Bill] y 1,2,3 y Apple] [

Una manera no demasiado perfecta y no muy divertida!

String[] array = new String[] { "7, 7, 7","Bill", "Bob", "Steve", "[Bill]",
        "1,2,3", "Apple ][" };
String join = " and ";

for (int i = 0; i < array.length; i++) array[i] = array[i].replaceAll(", ", "~,~");
String joined = Arrays.toString(array).replaceAll(", ", join)
        .replaceAll("(^//[)|(//]$)", "").replaceAll("~,~", ", ");

System.out.println(joined);

Salida:

7, 7, 7 y Bill y Bob y Steve y [Bill] y 1,2,3 y Apple] [

Answer 21

Una forma ortodoxa de lograrlo, es definiendo una nueva función:

public static String join(String join, String... strings) {
    if (strings == null || strings.length == 0) {
        return "";
    } else if (strings.length == 1) {
        return strings[0];
    } else {
        StringBuilder sb = new StringBuilder();
        sb.append(strings[0]);
        for (int i = 1; i < strings.length; i++) {
            sb.append(join).append(strings[i]);
        }
        return sb.toString();
    }
}

Muestra:

String[] array = new String[] { "7, 7, 7", "Bill", "Bob", "Steve",
        "[Bill]", "1,2,3", "Apple ][","~,~" };

String joined;
joined = join(" and ","7, 7, 7", "Bill", "Bob", "Steve", "[Bill]", "1,2,3", "Apple ][","~,~");
joined = join(" and ", array); // same result

System.out.println(joined);

Salida:

7, 7, 7 y Bill y Bob y Steve y [Bill] y 1,2,3 y Apple] [y ~, ~

Answer 22

EDITAR

También me doy cuenta del problema de implementación subyacente de toString() y del elemento que contiene el separador, pero pensé que estaba siendo paranoico.

Ya que tengo dos comentarios al respecto, estoy cambiando mi respuesta a:

    static String join( List<String> list , String replacement  ) {
        StringBuilder b = new StringBuilder();
        for( String item: list ) { 
            b.append( replacement ).append( item );
        }
        return b.toString().substring( replacement.length() );
    }

Que se parece bastante a la pregunta original.

Entonces, si no tienes ganas de agregar todo el frasco a tu proyecto, puedes usar esto.

Creo que no hay nada malo con su código original. En realidad, la alternativa que sugiere todo el mundo parece casi la misma (aunque tiene varias validaciones adicionales)

Aquí está, junto con la licencia Apache 2.0.

public static String join(Iterator iterator, String separator) {
       // handle null, zero and one elements before building a buffer
       if (iterator == null) {
           return null;
       }
       if (!iterator.hasNext()) {
           return EMPTY;
       }
       Object first = iterator.next();
       if (!iterator.hasNext()) {
           return ObjectUtils.toString(first);
       }

       // two or more elements
       StringBuffer buf = new StringBuffer(256); // Java default is 16, probably too small
       if (first != null) {
           buf.append(first);
       }

       while (iterator.hasNext()) {
           if (separator != null) {
               buf.append(separator);
           }
           Object obj = iterator.next();
           if (obj != null) {
               buf.append(obj);
           }
       }
       return buf.toString();
   }

Ahora lo sabemos, gracias a la fuente abierta.