Java: ¿función para matrices como join () de PHP?

Quiero unirme String[]con una cadena de pegamento. ¿Hay una función para esto?

A partir de Java8 es posible usarlo String.join().

String.join(", ", new String[]{"Hello", "World", "!"})

Genera:

Hello, World, !

De lo contrario, Apache Commons Lang tiene una StringUtilsclase que tiene una joinfunción que unirá matrices para crear un String.

Por ejemplo:

StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")

Genera lo siguiente String:

Hello, World, !

Si estabas buscando qué usar en Android, es:

String android.text.TextUtils.join(CharSequence delimiter, Object[] tokens)

por ejemplo:

String joined = TextUtils.join(";", MyStringArray);

En Java 8 puedes usar

1) Stream API:

String[] a = new String[] {"a", "b", "c"};
String result = Arrays.stream(a).collect(Collectors.joining(", "));

2) nuevo método String.join: https://stackoverflow.com/a/21756398/466677

3) clase java.util.StringJoiner: http://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html

Podría escribir fácilmente una función de este tipo en aproximadamente diez líneas de código:

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 pequeño mod en lugar de usar substring ():

//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();
}

Como con muchas preguntas últimamente, Java 8 al rescate:

Java 8 agregó un nuevo método estático al java.lang.Stringque hace exactamente lo que quieres:

public static String join(CharSequence delimeter, CharSequence... elements);

Utilizándolo:

String s = String.join(", ", new String[] {"Hello", "World", "!"});

Resultados en:

"Hello, World, !"

La biblioteca de guayaba de Google también tiene este tipo de capacidad . Puede ver el ejemplo de Cadena [] también desde la API.

Como ya se describió en la api, tenga cuidado con la inmutabilidad de los métodos de construcción.

Puede aceptar una variedad de objetos para que funcione en su caso. En mi experiencia anterior, intenté unirme a una pila que es iterable y funciona bien.

Muestra de mí:

Deque<String> nameStack = new ArrayDeque<>();
nameStack.push("a coder");
nameStack.push("i am");
System.out.println("|" + Joiner.on(' ').skipNulls().join(nameStack) + "|");

imprime: |i am a coder|

Dado:

String[] a = new String[] { "Hello", "World", "!" };

Luego, como alternativa a la respuesta de Coobird, donde el pegamento es ",":

Arrays.asList(a).toString().replaceAll("^\\[|\\]$", "")

O para concatenar con una cadena diferente, como "& amp;".

Arrays.asList(a).toString().replaceAll(", ", " & ").replaceAll("^\\[|\\]$", "")

Sin embargo ... este SOLO funciona si sabe que los valores en la matriz o lista NO contienen la cadena de caracteres ",".

Si está utilizando Spring Framework, entonces tiene la clase StringUtils :

import static org.springframework.util.StringUtils.arrayToDelimitedString;

arrayToDelimitedString(new String[] {"A", "B", "C"}, "\n");

No en el núcleo, no. Sin embargo, la búsqueda de "java array join string glue" le dará algunos fragmentos de código sobre cómo lograr esto.

p.ej

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();
}

Si aterrizó aquí buscando una conversión rápida de matriz a cadena, pruebe Arrays.toString () .

Crea una representación de cadena del Object[]pasado. El resultado está rodeado de corchetes ( "[]"), cada elemento se convierte en una Cadena a través de String.valueOf(Object)y se separa por ", ". Si la matriz es null, entonces "null"se devuelve.

Solo por el "Tengo el más corto" desafío , aquí hay minas;)

Iterativo:

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();
}

Recursivo:

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)));
}

Nada incorporado que yo sepa.

Apache Commons Lang tiene una clase llamada StringUtilsque contiene muchas funciones de combinación.

Así es como lo hago.

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();
}

Una alternativa 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();
}

Mi giro

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, "");
}

¿Te gusta mi forma de 3 líneas usando solo los métodos de la clase String?

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());
}

Para obtener "str1, str2" de "str1", "str2", "":

Stream.of("str1", "str2", "").filter(str -> !str.isEmpty()).collect(Collectors.joining(", ")); 

También puede agregar cheque nulo adicional

En caso de que esté usando la biblioteca funcional de Java y por alguna razón no pueda usar Streams de Java 8 (que podría ser el caso al usar el complemento Android + Retrolambda), aquí hay una solución funcional para usted:

String joinWithSeparator(List<String> items, String separator) {
    return items
            .bind(id -> list(separator, id))
            .drop(1)
            .foldLeft(
                    (result, item) -> result + item,
                    ""
            );
}

Tenga en cuenta que no es el enfoque más eficiente, pero funciona bien para listas pequeñas.

Lo hago de esta manera usando 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)

Hay una técnica simple de taquigrafía que uso la mayoría de las veces.

String op = new String;
for (int i : is) 
{
    op += candidatesArr[i-1]+",";
}
op = op.substring(0, op.length()-1);

java.util.Arrays tiene un método 'asList'. Junto con la API java.util.List / ArrayList, esto le brinda todo lo que necesita :;

private static String[] join(String[] array1, String[] array2) {

    List<String> list = new ArrayList<String>(Arrays.asList(array1));
    list.addAll(Arrays.asList(array2));
    return list.toArray(new String[0]);
}