Java-Äquivalent zum implodierten PHP (',', array_filter (array ()))

Ich benutze diesen Code oft in PHP

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

Es löscht leere Zeichenfolgen und verbindet sie mit einem ",". Wenn nur noch eines übrig bleibt, wird kein zusätzliches nicht benötigtes Komma hinzugefügt. Am Ende wird kein Komma hinzugefügt. Wenn keine übrig bleibt, wird eine leere Zeichenfolge zurückgegeben.

Somit kann ich eines der folgenden Ergebnisse erhalten

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

Was ist die beste Java-Implementierung (weniger Code) in Java, ohne dass externe Bibliotheken hinzugefügt werden müssen (Design für Android)?

Aktualisierte Version mit Java 8 (Original am Ende des Beitrags)

Wenn Sie keine Elemente filtern müssen, können Sie diese verwenden

• String.join (CharSequence-Trennzeichen, CharSequence...Elemente)

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

• oder String.join (CharSequence-Trennzeichen, Iterable<? extends CharSequence>Elemente)

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

Seit Java 8 können wir unseren Code verwenden StringJoiner(anstatt ursprünglich verwendet StringBulder) und vereinfachen.
Um zu vermeiden, dass " *"Regex bei jedem Aufruf von neu kompiliert wird, matches(" *")können wir ein separates Muster erstellen, das die kompilierte Version in einem bestimmten Feld enthält und bei Bedarf verwendet.

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

Bei Streams kann unser Code so aussehen.

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

Wenn wir Streams verwenden, können wir filterElemente, die Predicate. In diesem Fall möchten wir, dass das Prädikat Zeichenfolgen akzeptiert, die nicht nur Leerzeichen sind. Mit anderen Worten, Zeichenfolgen müssen Nicht-Leerzeichen enthalten.

Wir können ein solches Prädikat aus dem Muster erstellen. Prädikats erstellt diese Art und Weise werden alle Strings akzeptieren , die Zeichenkette enthalten wird , die durch regex abgestimmt werden (also wenn regex für aussehen "\\S"Prädikat wird Strings wie akzeptieren "foo ", " foo bar ", "whatever", aber nicht akzeptieren " "noch " ").

Also können wir verwenden

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

oder möglicherweise etwas aussagekräftiger, Negation von Zeichenfolgen, die nur Leerzeichen oder leer sind

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

Wenn der Filter alle leeren oder nur Leerzeichen enthaltenden Zeichenfolgen entfernt, können wir die collectrestlichen Elemente entfernen . Dank Collectors.joiningkönnen wir entscheiden, welches Trennzeichen verwendet werden soll.

Ursprüngliche Antwort (vor 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();
}

Sie können es wie verwenden

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

oder

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

Ausgabe ab, abs

Warum so ernst? Versuchen Sie es StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")!

Hier ist eine Android-spezifische Antwort, die für einige hilfreich sein kann:

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

// Result => Red,Green,Blue

Stellen Sie sicher, dass Sie die TextUtils-Klasse importieren:

import android.text.TextUtils;

Sie müssten Ihre Zeichenfolgen zu einer ArrayList hinzufügen, leere entfernen und entsprechend formatieren:

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

Wenn Sie über String[]ein Array von Zeichenfolgen verfügen, können Sie diese außerdem einfach zu einer ArrayList hinzufügen:

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

Ein einfaches Implodieren

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

Sie können dafür Überladungen erstellen.

Das obige Äquivalent von PHP implodiert.
Folgendes möchten Sie:

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

Die Verwendung von Streams (für Java 8 und höher) wäre hierfür eine alternative mögliche Lösung.

Sie müssen importieren

java.util.stream.Collectors;

um den Join-Prozess zu verwenden

Sie können verwenden:

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

um das gewünschte Ergebnis zu erzielen.

Hier ist meine implodierende Implementierung:

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

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

Verwenden Sie diese einfache Funktion:

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

Verwenden:

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