Java: função para matrizes como o join () do PHP?

Eu quero juntar um String[]com uma corda de cola. Existe uma função para isso?

A partir do Java8 , é possível usar String.join().

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

Gera:

Hello, World, !

Caso contrário, o Apache Commons Lang tem uma StringUtilsclasse que possui uma joinfunção que unirá matrizes para criar a String.

Por exemplo:

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

Gera o seguinte String:

Hello, World, !

Se você estava procurando o que usar no Android, é:

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

por exemplo:

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

No Java 8 você pode usar

1) API de fluxo:

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

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

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

Você poderia escrever facilmente essa função em cerca de dez linhas 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();
}

Um pequeno mod em vez 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 com muitas perguntas recentemente, o Java 8 para o resgate:

O Java 8 adicionou um novo método estático ao java.lang.Stringqual faz exatamente o que você deseja:

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

Usando isso:

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

Resulta em:

"Hello, World, !"

A biblioteca do Google goiaba também possui esse tipo de capacidade . Você pode ver o exemplo String [] também na API.

Como já descrito na API, tenha cuidado com a imutabilidade dos métodos do construtor.

Ele pode aceitar uma variedade de objetos para funcionar no seu caso. Na minha experiência anterior, tentei ingressar em um Stack que é iterável e funciona bem.

Amostra de mim:

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

Então, como uma alternativa à resposta de coobird, onde a cola é ",":

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

Ou para concatenar com uma sequência diferente, como "& amp;".

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

No entanto ... este funciona SOMENTE se você souber que os valores na matriz ou na lista NÃO contêm a cadeia de caracteres ",".

Se você estiver usando o Spring Framework , terá a classe StringUtils :

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

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

Não no núcleo, não. Uma pesquisa por "cola de cadeia de junção de matriz java" fornecerá alguns trechos de código sobre como conseguir isso.

por exemplo

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

Se você chegou aqui procurando uma conversão rápida de matriz para string, tente Arrays.toString () .

Cria uma representação String do Object[]passado. O resultado é cercado por colchetes ( "[]"), cada elemento é convertido em uma String por meio de String.valueOf(Object)e separado por ", ". Se a matriz for null, então "null"será retornado.

Apenas para o desafio "Eu tenho o menor" , aqui estão as 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 embutido que eu conheça.

O Apache Commons Lang tem uma classe chamada StringUtilsque contém muitas funções de junção.

É assim que eu faç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();
}

Uma alternativa semelhante

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

Minha rotação.

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

Você gosta do meu caminho de 3 linhas usando apenas os métodos da classe 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 obter "str1, str2" de "str1", "str2", "":

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

Além disso, você pode adicionar verificação nula extra

Caso você esteja usando a biblioteca Java Funcional e, por algum motivo, não possa usar o Streams do Java 8 (que pode ser o caso ao usar o plug-in Android + Retrolambda), aqui está uma solução funcional para você:

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

Observe que não é a abordagem mais eficiente, mas funciona bem para pequenas listas.

Eu faço dessa maneira usando um 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)

Existe uma técnica simples de taquigrafia que uso na maioria das vezes.

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

java.util.Arrays possui um método 'asList'. Juntamente com a API java.util.List / ArrayList, você fornece tudo o que você precisa :;

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