utilizando - Java: ¿Función para matrices como la combinación PHP()?

operaciones con matrices en java utilizando interfaz grafica

Question

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

Answer 1

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

Answer 2

¿Te gusta mi forma de 3 líneas usando solo los métodos de 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());
}

Answer 3

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

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

Genera:

Hello, World, !

De lo contrario, Apache Commons Lang tiene una clase StringUtils que tiene una función de join que unirá matrices para formar una String .

Por ejemplo:

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

Genera la siguiente String :

Hello, World, !

Answer 4

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

Answer 5

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 de la matriz o lista NO contienen la cadena de caracteres ",".

Answer 6

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://.com/a/21756398/466677

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

Answer 7

En caso de que esté utilizando la biblioteca funcional de Java y por alguna razón no pueda usar Streams de Java 8 (que podría ser el caso cuando se usa el complemento Android + Retrolambda), esta es 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.

Answer 8

Fácilmente podría escribir 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();
}

Answer 9

La biblioteca de Google guava también tiene este tipo de capacidad . Puedes ver el ejemplo de String [] 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 un 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|

Answer 10

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)

Answer 11

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

Answer 12

Nada de lo incorporado que yo sepa.

Apache Commons Lang tiene una clase llamada StringUtils que contiene muchas funciones de unión.

Answer 13

No en el núcleo, no. Sin embargo, una 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();
}

Answer 14

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

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

También puedes añadir cheque nulo extra

Answer 15

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

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

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

Answer 16

Si estabas buscando qué usar en Android, es:

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

por ejemplo:

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

Answer 17

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

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

Answer 18

Solo para el desafío "Tengo el más corto" , aquí están las 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)));
}

Answer 19

Un pequeño mod en lugar de usar subcadena ():

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

Answer 20

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

Answer 21

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

Answer 22

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

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

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

Usándolo:

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

Resultados en:

"Hello, World, !"