not - Equivalente de Java de la implosión de PHP('','', array_filter(array()))

php vs java 2018

Question

A menudo uso este fragmento de código en PHP

$ordine[''address''] = implode('', '', array_filter(array($cliente[''cap''], $cliente[''citta''] ,$cliente[''provincia''])));

Borra cadenas vacías y las une con un ",". Si solo queda uno, no agrega una coma extra innecesaria. No agrega una coma al final. Si no queda ninguno, devuelve una cadena vacía.

Así puedo obtener uno de los siguientes resultados

""
"Street abc 14"
"Street abc 14, 00168"
"Street abc 14, 00168, Rome"

¿Cuál es la mejor implementación de Java (menos código) en Java sin tener que agregar bibliotecas externas (diseño para Android)?

Answer 1

Versión actualizada utilizando Java 8 (original al final de la publicación)

Si no necesita filtrar ningún elemento, puede usar

• String.join (delimitador CharSequence, elementos CharSequence... )

  • String.join(" > ", new String[]{"foo", "bar"});
  • String.join(" > ", "foo", "bar");
    
    

• o String.join (delimitador de secuencia Char, elementos Iterable<? extends CharSequence> )

  • String.join(" > ", Arrays.asList("foo", "bar"));

Desde Java 8 podemos usar StringJoiner (en lugar de StringBulder utilizado originalmente) y simplificar nuestro código.
Además, para evitar la recompilación de " *" expresiones regulares en cada llamada de matches(" *") , podemos crear un patrón separado que contendrá su versión compilada en algún campo y usarlo cuando sea necesario.

private static final Pattern SPACES_OR_EMPTY = Pattern.compile(" *");
public static String implode(String separator, String... data) {
    StringJoiner sb = new StringJoiner(separator);
    for (String token : data) {
        if (!SPACES_OR_EMPTY.matcher(token).matches()) {
            sb.add(token);
        }
    }
    return sb.toString();
}   

Con streams, nuestro código puede ser similar.

private static final Predicate<String> IS_NOT_SPACES_ONLY = 
        Pattern.compile("^//s*$").asPredicate().negate();

public static String implode(String delimiter, String... data) {
    return Arrays.stream(data)
            .filter(IS_NOT_SPACES_ONLY)
            .collect(Collectors.joining(delimiter));
}

Si usamos streams, podemos filter elementos Predicate . En este caso, queremos que el predicado acepte cadenas que no son solo espacios; en otras palabras, la cadena debe contener un carácter que no sea de espacio en blanco.

Podemos crear dicho predicado a partir del patrón. El predicado creado de esta forma aceptará cualquier cadena que contenga subcadena que podría corresponderse con regex (de modo que si regex buscará el predicado "//S" aceptará cadenas como "foo " , " foo bar " , "whatever" , pero no aceptar " " ni " " ).

Entonces podemos usar

Pattern.compile("//S").asPredicate();

o posiblemente un poco más descriptivo, negación de cadenas que son solo espacios, o vacías

Pattern.compile("^//s*$").asPredicate().negate();

A continuación, cuando el filtro eliminará todos los espacios vacíos, o que contengan solo espacios, podemos collect resto de los elementos. Gracias a Collectors.joining podemos decidir qué delimitador usar.

Respuesta original (antes de Java 8)

public static String implode(String separator, String... data) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < data.length - 1; i++) {
    //data.length - 1 => to not add separator at the end
        if (!data[i].matches(" *")) {//empty string are ""; " "; "  "; and so on
            sb.append(data[i]);
            sb.append(separator);
        }
    }
    sb.append(data[data.length - 1].trim());
    return sb.toString();
}

Puedes usarlo como

System.out.println(implode(", ", "ab", " ", "abs"));

o

System.out.println(implode(", ", new String[] { "ab", " ", "abs" }));

Salida ab, abs

Answer 2

¿Por qué tan serio? Prueba StringUtils.join(new String[] {"Hello", "World", "!"}, ", ") !

Answer 3

Aquí está mi implementación implode:

/**
 * Implodes the specified items, gluing them using the specified glue replacing nulls with the specified
 * null placeholder.
 * @param glue              The text to use between the specified items.
 * @param nullPlaceholder   The placeholder to use for items that are <code>null</code> value.
 * @param items             The items to implode.
 * @return  A <code>String</code> containing the items in their order, separated by the specified glue.
 */
public static final String implode(String glue, String nullPlaceholder, String ... items) {
    StringBuilder sb = new StringBuilder();
    for (String item : items) {
        if (item != null) {
            sb.append(item);
        } else {
            sb.append(nullPlaceholder);
        }
        sb.append(glue);
    }
    return sb.delete(sb.length() - glue.length(), sb.length()).toString();
}

Answer 4

Aquí hay una respuesta específica de Android que puede ser útil para algunos

String combined = TextUtils.join(",", new String[]{"Red", "Green", "Blue"});

//Result => Red,Green,Blue

Asegúrese de importar la clase TextUtils

import android.text.TextUtils;

Answer 5

Tendría que agregar sus cadenas a una ArrayList, eliminar las vacías y formatearlas en consecuencia:

public static String createAddressString( String street, String zip_code, String country) {
    List<String> list = new ArrayList<String>();
    list.add( street);
    list.add( zip_code);
    list.add( country);

    // Remove all empty values
    list.removeAll(Arrays.asList("", null));

    // If this list is empty, it only contained blank values
    if( list.isEmpty()) {
        return "";
    }

    // Format the ArrayList as a string, similar to implode
    StringBuilder builder = new StringBuilder();
    builder.append( list.remove(0));

    for( String s : list) {
        builder.append( ", ");
        builder.append( s);
    }

    return builder.toString();
}

Además, si tenía String[] , una matriz de cadenas, puede agregarlas fácilmente a una ArrayList:

String[] s;
List<String> list = new ArrayList<String>( Arrays.asList( s));

Answer 6

Un simple Implode

public static String implode(String glue, String[] strArray)
{
    String ret = "";
    for(int i=0;i<strArray.length;i++)
    {
        ret += (i == strArray.length - 1) ? strArray[i] : strArray[i] + glue;
    }
    return ret;
}

Puede crear sobrecargas para ello ..

El anterior es equivalente a php implode.
Esto es lo que quieres:

import java.lang.*
public static String customImplode(String glue, String[] strArray)
{
    String ret = "";
    for(int i=0;i<strArray.length;i++)
    {
        if (strArray[i].trim() != "")
            ret += (i == strArray.length - 1) ? strArray[i] : strArray[i] + glue;
    }
    return ret;
}

Answer 7

Usar Streams (para Java 8 y versiones posteriores) sería una solución alternativa posible para esto. Usted está obligado a importar

java.util.stream.Collectors;

para usar el proceso de unión

Puedes utilizar:

Arrays.asList("foo","bar").stream().collect(Collectors.joining(","));

para lograr el resultado deseado

Answer 8

usa esta simple función:

private String my_implode(String spacer,String[] in_array){

    String res = "";

    for(int i = 0 ; i < in_array.length ; i++){

        if( !res.equals("") ){
            res += spacer;
        }
        res += in_array[i];
    }

    return res;
}

utilizar :

data_arr = {"d1","d2","d3"};
your_imploded_text = my_implode(",", data_arr);
//output : your_imploded_text = "d1,d2,d3"

Answer 9

public static String implode(List<String> items, String separator) {

        if (items == null || items.isEmpty()) {
            return null;
        }
        String delimiter = "";
        StringBuilder builder = new StringBuilder();
        for (String item : items) {
            builder.append(delimiter).append(item);
            delimiter = separator;
        }
        return builder.toString();
    }